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 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 override int PopWiredInt32() { if (this.GetRemainingLength() < 1) { return(0); } byte[] Data = this.ReadBytes(4); return(HabboEncoding.DecodeInt32(Data)); }
/// <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 int PopInt() { if (RemainingLength < 1) { return(0); } var data = PlainReadBytes(4); var i = HabboEncoding.DecodeInt32(data); _pointer += 4; return(i); }
public int PopInt() { if (RemainingLength < 4) { return(0); } byte[] Data = ReadBytes(4); Int32 i = HabboEncoding.DecodeInt32(Data); return(i); }
internal int PopWiredInt32() { if (isMobile) { return(int.Parse(MobileBody[Pointer++])); } if (this.RemainingLength < 1) { return(0); } int num = HabboEncoding.DecodeInt32(this.PlainReadBytes(4)); this.Pointer += 4; return(num); }
public int PopInt() { if (RemainingLength < 1) { return(0); } byte[] Data = PlainReadBytes(4); Int32 i = HabboEncoding.DecodeInt32(Data); Pointer += 4; return(i); }
internal Int32 PopWiredInt32() { if (RemainingLength < 1) { return(0); } var Data = PlainReadBytes(4); var i = HabboEncoding.DecodeInt32(Data); Pointer += 4; return(i); }
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 bool ReadByte(byte byte_) //returns if packet is fully readed { if (this.Lenght != null) { if (this.Packet == null) { this.Packet = new byte[(int)this.Lenght]; } this.Packet[this.Pointer++] = byte_; } else { if (this.LenghtBytes == null) { this.LenghtBytes = new byte?[4] { null, null, null, null }; } int i = 0; for (; i < this.LenghtBytes.Length; i++) { if (this.LenghtBytes[i] == null) { this.LenghtBytes[i] = byte_; break; } } if (i == 3) { this.Lenght = HabboEncoding.DecodeInt32(new byte[] { (byte)this.LenghtBytes[0], (byte)this.LenghtBytes[1], (byte)this.LenghtBytes[2], (byte)this.LenghtBytes[3] }); } return(false); } return(this.Pointer == this.Packet.Length); }
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 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); } }
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 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 int ReadInt32() { return(HabboEncoding.DecodeInt32(this.ReadBytes(4))); }
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); } }