private void InsertParamter(string paramName) { object value = null; byte[] data = HMessage.ToBytes(MainUI.PTPacketTxt.SelectedText); switch (paramName) { case "i": { if (data.Length == 4) { value = BigEndian.ToSI32(data); } break; } case "s": { if (data.Length >= 2) { int length = BigEndian.ToUI16(data); if (length == data.Length - 2) { value = Encoding.UTF8.GetString(data, 2, length); } } break; } case "b": { if (data.Length == 1) { value = Convert.ToBoolean(data[0]); } break; } } string param = $"{{{paramName}:{value}}}"; int start = (value == null ? MainUI.PTPacketTxt.TextLength : MainUI.PTPacketTxt.SelectionStart); if (value != null) { MainUI.PTPacketTxt.Text = MainUI.PTPacketTxt.Text.Remove( start, MainUI.PTPacketTxt.SelectedText.Length); } string valueString = value == null ? string.Empty : value.ToString(); MainUI.PTPacketTxt.Text = MainUI.PTPacketTxt.Text.Insert(start, param); MainUI.PTPacketTxt.Select(start + 3, valueString.Length); }
protected virtual T Decode <T>(Func <byte[], int, T> decoder, string value) { if (string.IsNullOrWhiteSpace(value)) { return(default(T)); } byte[] data = HMessage.ToBytes(value); return(decoder(data, 0)); }
private T Decode <T>(Func <byte[], T> decoder, string encoded) { if (string.IsNullOrWhiteSpace(encoded)) { return(default(T)); } byte[] data = HMessage.ToBytes(encoded); return(decoder(data)); }
/// <summary> /// Initializes a new instance of the <see cref="DataInterceptedEventArgs"/> class. /// </summary> /// <param name="packet">The intercepted message.</param> /// <param name="step">The current count/step/order of the intercepted message.</param> public DataInterceptedEventArgs(HMessage packet, int step, bool isOutgoing) { _ogData = packet.ToBytes(); _ogString = packet.ToString(); Step = step; Packet = packet; IsOutgoing = isOutgoing; Timestamp = DateTime.Now; }
/// <summary> /// Initializes a new instance of the <see cref="DataInterceptedEventArgs"/> class. /// </summary> /// <param name="continuation">The <see cref="Func{TResult}"/> of type <see cref="Task"/> that will be invoked when <see cref="ContinueRead"/> is called.</param> /// <param name="step">The current count/step/order from which this data was intercepted.</param> /// <param name="packet">The intercepted data to read/write from.</param> public DataInterceptedEventArgs(HMessage packet, int step, Func <Task> continuation) : base(continuation) { _ogData = packet.ToBytes(); _ogString = packet.ToString(); _ogDestination = packet.Destination; Step = step; Packet = packet; Executions = new List <HMessage>(); }
private void AttemptSendToClient(HMessage packet) { if (!packet.IsCorrupted) { Game.SendToClient(packet.ToBytes()); } else { MessageBox.Show(InjClientCanc, TanjiError, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
/// <summary> /// Initializes a new instance of the <see cref="InterceptedEventArgs"/> class. /// </summary> /// <param name="continuation">The <see cref="Func{TResult}"/> of type <see cref="Task"/> that will be invoked when <see cref="ContinueRead"/> is called.</param> /// <param name="step">The current count/step/order from which this data was intercepted.</param> /// <param name="packet">The intercepted data to read/write from.</param> public InterceptedEventArgs(Func <Task> continuation, int step, HMessage packet) { Executions = new List <HMessage>(); Continuation = continuation; IsAsyncCapable = (Continuation != null); Step = step; Packet = packet; Replacement = new HMessage( packet.ToBytes(), packet.Destination); }
private async Task <int> SendPacketInputAsync(HNode node) { try { MainUI.Cursor = Cursors.WaitCursor; string errorMessage = string.Empty; string packetTxt = MainUI.ITPacketTxt.Text; byte[] data = HMessage.ToBytes(packetTxt); if (data.Length < 6) { errorMessage = NOT_ENOUGH_DATA; errorMessage += $"\r\n\r\nYou're missing {6 - data.Length:#,##0} bytes."; } else { int realLength = data.Length - 4; int length = BigEndian.ToSI32(data); if (realLength != length) { bool tooSmall = length > realLength; int difference = Math.Abs(realLength - length); errorMessage = INVALID_PACKET_LENGTH; errorMessage += $"\r\n\r\nYou're {difference:#,##0} byte(s) too {(tooSmall ? "short" : "large")}."; } else { Task <int> sendTask = node.SendAsync(data); if (!MainUI.ITPacketTxt.Items.Contains(packetTxt)) { MainUI.ITPacketTxt.Items.Add(packetTxt); } return(await sendTask); } } MessageBox.Show(errorMessage, "Tanji ~ Error!", MessageBoxButtons.OK, MessageBoxIcon.Error); return(0); } finally { MainUI.Cursor = Cursors.Default; } }
public async void Connect() { //if(_proxyServer != null) ////_server.SOCKS5EndPoint = new IPEndPoint(IPAddress.Parse(_proxyServer), _proxyPort); /*try * { * Socket Client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); * Client.NoDelay = true; * IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("3.210.175.39"), 38101); * IAsyncResult result = Client.BeginConnect(endPoint, null, null); * await Task.Factory.FromAsync(result, Client.EndConnect).ConfigureAwait(false); * } * catch( Exception ex) * { * MessageBox.Show(ex.ToString()); * }*/ _server = HNode.ConnectNewAsync("game-us.habbo.com", 38101).Result; while (_server == null) { ; } if (_server.IsConnected) { _main.LogSucess("Connected to habbo server"); } HMessage releaseVerMsg = new HMessage(HMessage.ToBytes("{l}{u:4000}{s:PRODUCTION-202004272205-912004688}{s:FLASH}{i:1}{i:0}")); await _server.SendPacketAsync(releaseVerMsg); HMessage initCryptoMsg = new HMessage(HMessage.Construct(178, HMessage.ToBytes("[0][0][0][2][0]²"))); await _server.SendPacketAsync(initCryptoMsg); //await _server.SendPacketAsync(Headers.ReleaseVersion, Headers.Variables.Production, "FLASH", 1, 0); //await _server.SendPacketAsync(Headers.InitCrypto); HMessage packet = await _server.ReceivePacketAsync().ConfigureAwait(false); while (packet == null) { ; } HandlePacket(packet); //Listen(); }
protected void InsertParameter(string parameterName) { if (InputBox == null) { return; } string selectedValue = InputBox.SelectedText; object parameterValue = null; byte[] parameterData = HMessage.ToBytes(selectedValue); switch (parameterName) { case "i": { if (parameterData.Length == 4) { parameterValue = BigEndian.ToInt32(parameterData, 0); } break; } case "s": { if (parameterData.Length >= 2 && (BigEndian.ToUInt16(parameterData, 0) == (parameterData.Length - 2))) { parameterValue = Encoding.UTF8.GetString( parameterData, 2, parameterData.Length - 2); } break; } case "b": { if (parameterData.Length == 1) { parameterValue = BigEndian.ToBoolean(parameterData, 0); } break; } } InsertParameter(parameterName, parameterValue); }
private void EDExtractValuesBtn_Click(object sender, EventArgs e) { EDExtracterLstvw.Items.Clear(); byte[] encodedBlocks = HMessage.ToBytes(EDEncodedBlocksTxt.Text); if (encodedBlocks.Length % 4 == 0) { int value = 0; string encoded = string.Empty; byte[] encodedBlock = new byte[4]; for (int i = 0; i < encodedBlocks.Length; i += 4) { Buffer.BlockCopy(encodedBlocks, i, encodedBlock, 0, 4); value = BigEndian.DecypherInt(encodedBlock); encoded = HMessage.ToString(encodedBlock); EDExtracterLstvw.FocusAdd(value.ToString(), encoded, i.ToString()); } } }
private void IPPrimitiveTxt_TextChanged(object sender, EventArgs e) { if (IPPrimitiveTxt.TextLength < 1) { IPacketTxt.Text = string.Empty; } else if (IPPrimitiveTxt.TextLength < 2) { return; } HMessage packet = null; bool isCorrupted = false; try { byte[] data = HMessage.ToBytes(IPPrimitiveTxt.Text); if (data.Length >= 6) { packet = new HMessage(data); isCorrupted = (data.Length < 2 || packet.IsCorrupted); } else { isCorrupted = true; } } catch { isCorrupted = true; } finally { IPacketTxt.Text = isCorrupted ? IPPrimitiveTxt.Text : packet.ToString(); IPPacketInfoLbl.Text = string.Format(PRIMITIVE_INFO_FORMAT, (isCorrupted ? 0 : packet.Header), (isCorrupted ? IPPrimitiveTxt.TextLength : packet.Length)); IPIsCorruptedLbl.Text = isCorrupted.ToString(); IPIsCorruptedLbl.ForeColor = isCorrupted ? Color.Firebrick : SystemColors.HotTrack; IPIsCorruptedLbl.Location = new Point((IPPacketInfoLbl.Location.X + IPPacketInfoLbl.Width) - 5, IPIsCorruptedLbl.Location.Y); } }
private void RealignBtn_Click(object sender, EventArgs e) { if (InputBox == null) { return; } int packetHeaderEnd = 0; if (!InputBox.Text.StartsWith("{l}{u:")) { ushort packetHeader = 0; byte[] packetData = HMessage.ToBytes(InputBox.Text); if (packetData.Length >= 6) { int packetLength = BigEndian.ToInt32(packetData, 0); packetHeader = BigEndian.ToUInt16(packetData, 4); byte[] headerData = new byte[6]; Buffer.BlockCopy(packetData, 0, headerData, 0, 6); if (packetLength == (packetData.Length - 4)) { string formattedHeader = HMessage.ToString(headerData); InputBox.Text = InputBox.Text.Remove(0, formattedHeader.Length); } } InputBox.Text = InputBox.Text.Insert(0, $"{{l}}{{u:{packetHeader}}}"); packetHeaderEnd = packetHeader.ToString().Length; } else { string formattedHeader = InputBox.Text .GetChild("{l}{u:").GetParent("}"); packetHeaderEnd = formattedHeader.Length; } InputBox.Select(6, packetHeaderEnd); InputBox.ScrollToCaret(); }
private void EDTDecodeValuesBtn_Click(object sender, EventArgs e) { MainUI.EDTDecodedVw.Items.Clear(); string encodedBlocks = MainUI.EDTEncodedValuesTxt.Text; byte[] data = HMessage.ToBytes(encodedBlocks); if (data.Length % 4 != 0) { return; } for (int i = 0; i < data.Length; i += 4) { var block = new byte[4]; Buffer.BlockCopy(data, i, block, 0, 4); int value = BigEndian.ToSI32(block); string encoded = HMessage.ToString(block); MainUI.EDTDecodedVw.FocusAdd(value, encoded, i); } }
private void SendTo(HMessage packet) { Func <byte[], int> sendToX = null; switch (packet.Destination) { case HDestination.Client: sendToX = Game.SendToClient; break; case HDestination.Server: sendToX = Game.SendToServer; break; case HDestination.Unknown: throw new Exception("Unsupported HDestination type provided: HDestination.Unknown"); } if (!packet.IsCorrupted) { sendToX(packet.ToBytes()); } else { MessageBox.Show(InjClientCanc, "Tanji ~ Error!", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public bool IsInjectionAuthorized(HMessage packet) { if (!IsInjectionAuthorized()) { return(false); } if (!packet.IsCorrupted) { return(true); } else { byte[] data = packet.ToBytes(); string alertMsg = PACKET_LENGTH_INVALID; if (data.Length < 6) { alertMsg += $"\r\n\r\nYou're missing {6 - data.Length:#,##0} byte(s)."; } else { int length = (data.Length > 0 ? BigEndian.ToInt32(data, 0) : 0); int realLength = (data.Length - 4); bool tooShort = (length > realLength); int difference = Math.Abs(realLength - length); alertMsg += $"\r\n\r\nYou're {difference:#,##0} byte(s) too {(tooShort ? "short" : "big")}."; } MessageBox.Show(alertMsg, "Tanji ~ Alert!", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); return(false); } }
private void PTLengthHeaderBtn_Click(object sender, EventArgs e) { int endSelect = 0; if (!MainUI.PTPacketTxt.Text.StartsWith("{l}{u:")) { string headerString = "0"; byte[] data = HMessage.ToBytes(MainUI.PTPacketTxt.Text); if (data.Length >= 6) { int length = BigEndian.ToSI32(data); ushort header = BigEndian.ToUI16(data, 4); byte[] headerLength = new byte[6]; Buffer.BlockCopy(data, 0, headerLength, 0, 6); if (length == (data.Length - 4)) { headerString = header.ToString(); string toReplace = HMessage.ToString(headerLength); MainUI.PTPacketTxt.Text = MainUI.PTPacketTxt.Text.Remove(0, toReplace.Length); } } MainUI.PTPacketTxt.Text = MainUI.PTPacketTxt.Text.Insert(0, $"{{l}}{{u:{headerString}}}"); endSelect = headerString.Length; } else { string headerLengthParamValue = MainUI.PTPacketTxt.Text .GetChild("{l}{u:").GetParent("}"); endSelect = headerLengthParamValue.Length; } MainUI.PTPacketTxt.Select(6, endSelect); }
public int SendPacket(HMessage packet) { return(Send(packet.ToBytes())); }
public byte[] GetBytes() { return(_packet.ToBytes()); }
private void SendToAll(HMessage Packet, int Amount = 0) { SendToAll(Packet.ToBytes(), Amount); }
public Task <int> SendPacketAsync(HMessage packet, CancellationToken cancellationToken) { return(SendAsync(packet.ToBytes(), cancellationToken)); }
public Task <int> SendToServerAsync(ushort header, params object[] chunks) { var outMessage = new HMessage(1, HMessage.Construct(header, chunks)); return(_externalContractor.SendAsync(outMessage.ToBytes())); }
public Task <int> SendToServerAsync(byte[] data) { var outMessage = new HMessage(1, data); return(_externalContractor.SendAsync(outMessage.ToBytes())); }
public Task <int> SendToClientAsync(ushort header, params object[] chunks) { var inMessage = new HMessage(0, HMessage.Construct(header, chunks)); return(_externalContractor.SendAsync(inMessage.ToBytes())); }
public Task <int> SendToClientAsync(byte[] data) { var inMessage = new HMessage(0, data); return(_externalContractor.SendAsync(inMessage.ToBytes())); }
public Task <int> SendToServerAsync(HMessage packet) { return(SendToServerAsync(packet.ToBytes())); }
private byte[] GetInputPacket() { return(PacketTxt.TextLength > 0 ? HMessage.ToBytes(PacketTxt.Text) : null); }
public Task <int> SendPacketAsync(HMessage packet) { return(SendAsync(packet.ToBytes())); }
public Task <int> SendPacketAsync(string signature) { return(SendAsync(HMessage.ToBytes(signature))); }
public byte[] GetBytes() => _packet.ToBytes();