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();
