private ClientMessage TryParseAsNewCrypto(byte[] packet) { try { int i = 0; while (i < packet.Length) { int lenght = HabboEncoding.DecodeInt32(new byte[] { (byte)packet[i++], (byte)packet[i++], (byte)packet[i++], (byte)packet[i++] }); if (lenght > 0) { uint id = (uint)HabboEncoding.DecodeInt16(new byte[] { (byte)packet[i++], (byte)packet[i++] }); if (id > 0) { byte[] bytes = new byte[lenght - 2]; for (int j = 0; j < bytes.Length; j++) { bytes[j] = packet[i++]; } NewCryptoClientMessage crypto = new NewCryptoClientMessage(); crypto.Init(id, bytes); return(crypto); } } } } catch { return(null); } return(null); }
public override bool HandlePacket(GameClient session, ref byte[] packet) { for (int i = 0; i < packet.Length; i++) { if (this.ReadByte(packet[i])) { NewCryptoClientMessage message = new NewCryptoClientMessage(); message.Init((uint)HabboEncoding.DecodeInt16(new byte[] { this.Packet[0], this.Packet[1] }), this.Packet); message.Skip(2); session.HandlePacket(message); Array.Clear(this.Packet, 0, this.Packet.Length); this.Packet = null; this.Lenght = null; this.LenghtBytes = null; this.Pointer = 0; if (session.Disconnected) { return(false); //packet disconnected the user! :D } } } return(true); }
public void handlePacketData(byte[] data) { int position = 0; while (position < data.Length) { try { var MessageLength = HabboEncoding.DecodeInt32(new byte[] { data[position++], data[position++], data[position++], data[position++] }); if (MessageLength < 2 || MessageLength > 4096) { continue; } var MessageId = HabboEncoding.DecodeInt16(new byte[] { data[position++], data[position++] }); var Content = new byte[MessageLength - 2]; Buffer.BlockCopy(data, position, Content, 0, MessageLength - 2); position += MessageLength - 2; if (onNewPacket != null) { using (ClientMessage message = ClientMessageFactory.GetClientMessage(MessageId, Content)) { onNewPacket.Invoke(message); } } } catch { } } }
public byte[] ReadFixedValue() { int len = 0; if (RemainingLength >= 2) { len = HabboEncoding.DecodeInt16(ReadBytes(2)); } return(ReadBytes(len)); }
/// <summary> /// Handles the packet data. /// </summary> /// <param name="data">The data.</param> public void HandlePacketData(byte[] data) { var i = 0; if (data.Length == 0) { return; } while (i < data.Length) { if (data.Length - i < 6) { return; } short messageId = 0; try { var length = HabboEncoding.DecodeInt32(new[] { data[i++], data[i++], data[i++], data[i++] }); if (length < 2 || length > 4096) { return; } messageId = HabboEncoding.DecodeInt16(new[] { data[i++], data[i++] }); var packetContent = new byte[length - 2]; var num2 = 0; while (num2 < packetContent.Length && i < data.Length) { packetContent[num2] = data[i++]; num2++; } if (OnNewPacket == null) { continue; } using (var clientMessage = Factorys.GetClientMessage(messageId, packetContent)) OnNewPacket(clientMessage); } catch (Exception exception) { Logging.HandleException(exception, string.Format("packet handling ----> {0}", messageId)); _con.Dispose(); } } }
public void handlePacketData(byte[] data) { int pos = 0; while (pos < data.Length) { try { int MessageLength = HabboEncoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++], data[pos++] }); if (MessageLength < 2 || MessageLength > 1024) { //Logging.WriteLine("bad size packet!"); continue; } int MessageId = HabboEncoding.DecodeInt16(new byte[] { data[pos++], data[pos++] }); byte[] Content = new byte[MessageLength - 2]; for (int i = 0; i < Content.Length && pos < data.Length; i++) { Content[i] = data[pos++]; } //Logging.WriteLine("[REQUEST] [" + MessageId + " / len: " + MessageLength + "] => " + Encoding.Default.GetString(Content).Replace(Convert.ToChar(0).ToString(), "{char0}")); if (onNewPacket != null) { using (ClientMessage message = ClientMessageFactory.GetClientMessage(MessageId, Content)) { onNewPacket.Invoke(message); } } } catch (Exception e) { int MessageLength = HabboEncoding.DecodeInt32(new byte[] { data[pos++], data[pos++], data[pos++], data[pos++] }); int MessageId = HabboEncoding.DecodeInt16(new byte[] { data[pos++], data[pos++] }); Logging.HandleException(e, "packet handling ----> " + MessageId); con.Dispose(); } } }
public void ParsePacket(ref byte[] bytes) { //Console.WriteLine(Essential.GetDefaultEncoding().GetString(bytes)); string Packet = Essential.GetDefaultEncoding().GetString(bytes); if (Essential.GetDefaultEncoding().GetString(bytes) == "<policy-file-request/>" + (char)0) { this.Connection.SendMessage(CrossdomainPolicy.GetXmlPolicy()); } else if (Packet.StartsWith("GET") || Packet.StartsWith("POST")) { Essential.GetWebManager().HandleRequest(Packet, this.GetConnection()); } /*if(Packet.StartsWith("imaphone")) * { * //Essential.GetMobileHandler().HandleRequest(Packet, this); * }*/ int index = 0; while (index < bytes.Length) { try { // I tried to make a mobile Version of Habbo, but didn't continue it. If you want I could continue the developing of Essential Mobile if (!Packet.StartsWith("mobile")) { #region "Normal Part" int MessageLength = HabboEncoding.DecodeInt32(new byte[] { bytes[index++], bytes[index++], bytes[index++], bytes[index++] }); if (MessageLength < 2 || MessageLength > 1024) { //Console.WriteLine("bad size packet!"); continue; } int MessageId = HabboEncoding.DecodeInt16(new byte[] { bytes[index++], bytes[index++] }); byte[] Content = new byte[MessageLength - 2]; for (int i = 0; i < Content.Length && index < bytes.Length; i++) { Content[i] = bytes[index++]; } if (MessageId == 1615) { return; } Interface messageInterface; ClientMessage cMessage = new ClientMessage((uint)MessageId, Content); if (cMessage != null) { if (Essential.GetPacketManager().Handle((uint)MessageId, out messageInterface)) { try { /* Logging.WriteLine(string.Concat(new object[] * { * "[INCOMING] ", * "[", * messageInterface.GetType().Name.ToString(), * "] --> [", * cMessage.Id, * "] ", * cMessage.ToString() * }));*/ messageInterface.Handle(this, cMessage); } catch (Exception ex) { Logging.LogException("Error: " + ex.ToString()); } } } #endregion } else { #region "Mobile Part" if (Packet.Length < 2 || Packet.Length > 1024) { continue; } this.IsMobileUser = true; this.GetConnection().IsMobileUser = true; Interface messageInterface; uint MessageId = uint.Parse(Packet.Split((char)1)[1]); ClientMessage cMessage = new ClientMessage((uint)MessageId, null, true, Packet); if (cMessage != null) { if (Essential.GetPacketManager().Handle((uint)MessageId, out messageInterface)) { try { /* Logging.WriteLine(string.Concat(new object[] * { * "[INCOMING] ", * "[", * messageInterface.GetType().Name.ToString(), * "] --> [", * cMessage.Id, * "] ", * cMessage.ToString() * }));*/ messageInterface.Handle(this, cMessage); break; } catch (Exception ex) { Logging.LogException("Error: " + ex.ToString()); } } } #endregion } } catch (Exception e) { if (e.GetType() == typeof(IndexOutOfRangeException)) { return; } if (e.GetType() == typeof(NullReferenceException)) { return; } Logging.LogException("Error: " + e.ToString()); ServerMessage ServerError = new ServerMessage(Outgoing.ServerError); ServerError.AppendInt32(1); ServerError.AppendInt32(1); ServerError.AppendString(DateTime.Now.ToShortDateString().ToString()); this.SendMessage(ServerError); } } }
public byte[] ReadFixedValue() { var len = HabboEncoding.DecodeInt16(ReadBytes(2)); return(ReadBytes(len)); }
internal byte[] ReadFixedValue() { int bytes = HabboEncoding.DecodeInt16(this.ReadBytes(2)); return(this.ReadBytes(bytes)); }
public void HandlePacketData(byte[] data) { try { if (_client.Rc4Client != null && !_deciphered) { _client.Rc4Client.Decrypt(ref data); _deciphered = true; } if (_halfDataRecieved) { byte[] fullDataRcv = new byte[_halfData.Length + data.Length]; Buffer.BlockCopy(_halfData, 0, fullDataRcv, 0, _halfData.Length); Buffer.BlockCopy(data, 0, fullDataRcv, _halfData.Length, data.Length); _halfDataRecieved = false; // mark done this round HandlePacketData(fullDataRcv); // repeat now we have the combined array return; } using (BinaryReader reader = new BinaryReader(new MemoryStream(data))) { if (data.Length < 4) { return; } int msgLen = HabboEncoding.DecodeInt32(reader.ReadBytes(4)); if ((reader.BaseStream.Length - 4) < msgLen) { _halfData = data; _halfDataRecieved = true; return; } if (msgLen < 0 || msgLen > 5120)//TODO: Const somewhere. { return; } byte[] packet = reader.ReadBytes(msgLen); using (BinaryReader r = new BinaryReader(new MemoryStream(packet))) { int header = HabboEncoding.DecodeInt16(r.ReadBytes(2)); byte[] content = new byte[packet.Length - 2]; Buffer.BlockCopy(packet, 2, content, 0, packet.Length - 2); ClientPacket message = new ClientPacket(header, content); OnNewPacket.Invoke(message); _deciphered = false; } if (reader.BaseStream.Length - 4 > msgLen) { byte[] extra = new byte[reader.BaseStream.Length - reader.BaseStream.Position]; Buffer.BlockCopy(data, (int)reader.BaseStream.Position, extra, 0, (int)(reader.BaseStream.Length - reader.BaseStream.Position)); _deciphered = true; HandlePacketData(extra); } } } #pragma warning disable CS0168 // The variable 'e' is declared but never used catch (Exception e) #pragma warning restore CS0168 // The variable 'e' is declared but never used { //log.Error("Packet Error!", e); } }
public void handlePacketData(byte[] Data, bool deciphered = false) { try { if (OnNewPacket == null) { return; } if (Data.Length >= 2) { if (Data[0] == 60 && Data[1] == 112) { this.currentClient.GetConnection().SendData(Encoding.Default.GetBytes(GetXmlPolicy())); } } if (currentClient != null && !deciphered) { //currentClient.RC4Client.Decrypt(ref Data); } if (this._halfDataRecieved) { byte[] FullDataRcv = new byte[this._halfData.Length + Data.Length]; Buffer.BlockCopy(this._halfData, 0, FullDataRcv, 0, this._halfData.Length); Buffer.BlockCopy(Data, 0, FullDataRcv, this._halfData.Length, Data.Length); this._halfDataRecieved = false; // mark done this round handlePacketData(FullDataRcv); // repeat now we have the combined array return; } using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data))) { if (Data.Length < 4) { return; } int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4)); if (MsgLen <= 0 || MsgLen > (5120 * 2)) { return; } if ((Reader.BaseStream.Length - 4) < MsgLen) { this._halfData = Data; this._halfDataRecieved = true; return; } byte[] Packet = Reader.ReadBytes(MsgLen); using (BinaryReader R = new BinaryReader(new MemoryStream(Packet))) { int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2)); byte[] Content = new byte[Packet.Length - 2]; Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2); ClientPacket Message = new ClientPacket(Header, Content); OnNewPacket.Invoke(Message); } if (Reader.BaseStream.Length - 4 > MsgLen) { byte[] Extra = new byte[Reader.BaseStream.Length - Reader.BaseStream.Position]; Buffer.BlockCopy(Data, (int)Reader.BaseStream.Position, Extra, 0, ((int)Reader.BaseStream.Length - (int)Reader.BaseStream.Position)); handlePacketData(Extra, true); } } } catch (Exception e) { Console.WriteLine("Packet Error! " + e); } }
internal string PopFixedString() { return(OtanixEnvironment.GetDefaultEncoding().GetString(ReadBytes(HabboEncoding.DecodeInt16(ReadBytes(2))))); }
public void handlePacketData(byte[] Data, bool deciphered = false) { try { if (onNewPacket == null) { return; } if (Data[0] == 71 && Data[1] == 69) { PolicyRequest(Data); return; } try { Data = EncodeDecode.DecodeMessage(Data); } catch { return; } using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data))) { if (Data.Length < 4) { return; } int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4)); if ((Reader.BaseStream.Length) < MsgLen) { return; } if (MsgLen < 0 || MsgLen > 5120) { return; } byte[] Packet = Reader.ReadBytes(MsgLen); using (BinaryReader R = new BinaryReader(new MemoryStream(Packet))) { int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2)); byte[] Content = new byte[Packet.Length - 2]; Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2); ClientPacket Message = new ClientPacket(Header, Content); onNewPacket.Invoke(Message); } } } catch (Exception e) { Console.WriteLine("Packet Error! " + e); } }
public void handlePacketData(byte[] data) { int i = 0; if (currentClient != null && currentClient.ARC4 != null) { currentClient.ARC4.Decrypt(ref data); } checked { while (i < data.Length) { try { int num = HabboEncoding.DecodeInt32(new byte[] { data[i++], data[i++], data[i++], data[i++] }); if (num >= 2 && num <= 1024) { int messageId = HabboEncoding.DecodeInt16(new byte[] { data[i++], data[i++] }); byte[] array = new byte[num - 2]; int num2 = 0; while (num2 < array.Length && i < data.Length) { array[num2] = data[i++]; num2++; } if (this.onNewPacket != null) { using (ClientMessage clientMessage = ClientMessageFactory.GetClientMessage(messageId, array)) { this.onNewPacket(clientMessage); } } } } catch (Exception pException) { HabboEncoding.DecodeInt32(new byte[] { data[i++], data[i++], data[i++], data[i++] }); int num3 = HabboEncoding.DecodeInt16(new byte[] { data[i++], data[i++] }); Logging.HandleException(pException, "packet handling ----> " + num3); this.con.Dispose(); } } } }
public byte[] ReadFixedValue() { int len = HabboEncoding.DecodeInt16(this.ReadBytes(2)); return(this.ReadBytes(len)); }
internal byte[] ReadFixedValue() { int len = HabboEncoding.DecodeInt16(ReadBytes(2)); return(ReadBytes(len)); }
public void handlePacketData(byte[] Data) { try { if (currentClient.RC4Client != null && !_deciphered) { currentClient.RC4Client.Decrypt(ref Data); _deciphered = true; } if (_halfDataRecieved) { byte[] FullDataRcv = new byte[_halfData.Length + Data.Length]; Buffer.BlockCopy(_halfData, 0, FullDataRcv, 0, _halfData.Length); Buffer.BlockCopy(Data, 0, FullDataRcv, _halfData.Length, Data.Length); _halfDataRecieved = false; // mark done this round handlePacketData(FullDataRcv); // repeat now we have the combined array return; } using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data))) { if (Data.Length < 4) { return; } int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4)); if ((Reader.BaseStream.Length - 4) < MsgLen) { _halfData = Data; _halfDataRecieved = true; return; } else if (MsgLen < 0 || MsgLen > 5120)//TODO: Const somewhere. { return; } byte[] Packet = Reader.ReadBytes(MsgLen); using (BinaryReader R = new BinaryReader(new MemoryStream(Packet))) { int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2)); byte[] Content = new byte[Packet.Length - 2]; Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2); ClientPacket Message = new ClientPacket(Header, Content); OnNewPacket.Invoke(Message); _deciphered = false; } if (Reader.BaseStream.Length - 4 > MsgLen) { byte[] Extra = new byte[Reader.BaseStream.Length - Reader.BaseStream.Position]; Buffer.BlockCopy(Data, (int)Reader.BaseStream.Position, Extra, 0, (int)(Reader.BaseStream.Length - Reader.BaseStream.Position)); _deciphered = true; handlePacketData(Extra); } } } catch (Exception e) { log.Error("Packet Error!", e); } }
/// <summary> /// Handles the packet data. /// </summary> /// <param name="data">The data.</param> /// <param name="length">The length.</param> public void HandlePacketData(byte[] data, int length) { if (length > 0 && _currentClient != null) { try { int pos; for (pos = 0; pos < length;) { if (_currentPacketLength == -1) { if (length < IntSize) { BufferCopy(data, length); break; } _currentPacketLength = HabboEncoding.DecodeInt32(data, ref pos); } if (_currentPacketLength < 2 || _currentPacketLength > 4096) { _currentPacketLength = -1; break; } short messageId = 0; if (_currentPacketLength == length - pos + _bufferPos) { if (_bufferPos != 0) { BufferCopy(data, length, pos); pos = 0; messageId = HabboEncoding.DecodeInt16(_bufferedData, ref pos); HandleMessage(messageId, _bufferedData, 2, _currentPacketLength); } else { messageId = HabboEncoding.DecodeInt16(data, ref pos); HandleMessage(messageId, data, pos, _currentPacketLength); } pos = length; _currentPacketLength = -1; } else { int remainder = length - pos - (_currentPacketLength - _bufferPos); if (_bufferPos != 0) { int toCopy = remainder - _bufferPos; BufferCopy(data, toCopy, pos); int zero = 0; messageId = HabboEncoding.DecodeInt16(_bufferedData, ref zero); HandleMessage(messageId, _bufferedData, 2, _currentPacketLength); } else { messageId = HabboEncoding.DecodeInt16(data, ref pos); HandleMessage(messageId, data, pos, _currentPacketLength); // ReSharper disable once RedundantAssignment pos -= 2; } _currentPacketLength = -1; pos = length - remainder; } } } catch (Exception exception) { ServerLogManager.LogException(exception, "Yupi.Net.Packets.ServerPacketParser.HandlePacketData"); } } }
public override short ReadInt16() { return((short)HabboEncoding.DecodeInt16(this.ReadBytes(2))); }
public void HandlePacketData(byte[] Data) { try { if (CurrentClient.RC4Client != null && !Deciphered) { CurrentClient.RC4Client.Decrypt(ref Data); Deciphered = true; } if (HalfDataRecieved) { byte[] FullDataRcv = new byte[HalfData.Length + Data.Length]; Buffer.BlockCopy(HalfData, 0, FullDataRcv, 0, HalfData.Length); Buffer.BlockCopy(Data, 0, FullDataRcv, HalfData.Length, Data.Length); HalfDataRecieved = false; HandlePacketData(FullDataRcv); return; } using (BinaryReader Reader = new BinaryReader(new MemoryStream(Data))) { if (Data.Length < 4) { return; } int MsgLen = HabboEncoding.DecodeInt32(Reader.ReadBytes(4)); if ((Reader.BaseStream.Length - 4) < MsgLen) { HalfData = Data; HalfDataRecieved = true; return; } else if (MsgLen < 0 || MsgLen > 5120) { return; } byte[] Packet = Reader.ReadBytes(MsgLen); using (BinaryReader R = new BinaryReader(new MemoryStream(Packet))) { int Header = HabboEncoding.DecodeInt16(R.ReadBytes(2)); byte[] Content = new byte[Packet.Length - 2]; Buffer.BlockCopy(Packet, 2, Content, 0, Packet.Length - 2); ClientPacket Message = new ClientPacket(Header, Content); OnNewPacket.Invoke(Message); Deciphered = false; } if (Reader.BaseStream.Length - 4 > MsgLen) { byte[] Extra = new byte[Reader.BaseStream.Length - Reader.BaseStream.Position]; Buffer.BlockCopy(Data, (int)Reader.BaseStream.Position, Extra, 0, (int)(Reader.BaseStream.Length - Reader.BaseStream.Position)); Deciphered = true; HandlePacketData(Extra); } } } catch (Exception e) { //log.Error("Packet Error!", e); } }