public void Write(TransferBuffer data)
{
if (data.Data.Array != null)
{
this.stream.Write(data.Data.Array, data.Data.Offset, data.Data.Count);
}
}
public TransferBuffer(TransferBuffer rhs)
{
lock (rhs.m_lock)
{
m_buffer = new byte[rhs.m_buffer.Length];
System.Buffer.BlockCopy(rhs.m_buffer, 0, m_buffer, 0, m_buffer.Length);
m_offset = rhs.m_offset;
m_size = rhs.m_size;
m_lock = new object();
}
}
//Settings initialize
public PacketHandler()
{
m_Locker = new object();
n_Locker = new object();
m_bBlowfish = Program.cfgGateway.boolBlowfish;
m_bSecurityBytes = Program.cfgGateway.boolSecBytes;
m_bHandshake = Program.cfgGateway.boolHandshake;
m_bEncrypted = Program.cfgGateway.boolEncrypted;
m_Buffer = Program.cfgGateway.intMaxBuffer;
m_ServerName = Program.cfgGateway.strProgramNameHeader;
m_MaxBytesPerSecLimit = Program.cfgGateway.doubleMaxBytesPerSecLimit;
m_opcodeLimit = Program.cfgGateway.intOpcodeLimit;
m_LastPackets = new Queue <Packet>(Program.cfgGateway.intQueuePacketLimit);
m_localSecurity = new Security();
m_localSecurity.ChangeIdentity(m_ServerName, 0);
m_localTransferBuffer = new TransferBuffer(m_Buffer);
}
//Listen for ClientConnection on port
public void Listen(ushort port)
{
local_security = new Security();
local_security.GenerateSecurity(true, true, true);
local_recv_buffer = new TransferBuffer(MAX_RECV_SIZE, 0, 0);
local_listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
local_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
if (local_listener.IsBound == false)
{
local_listener.Bind(new IPEndPoint(IPAddress.Loopback, port));
local_listener.Listen(1);
}
local_listener.BeginAccept(new AsyncCallback(OnClientConnect), null);
Console.WriteLine("Listing for Client on 127.0.0.1:" + port);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private static void TCPTransferOutgoing(List <Context> contexts)
{
foreach (var context in contexts)
{
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
foreach (var kvp in context.Security.TransferOutgoing())
{
if (dumpTCP && context == contexts[1])
{
Utility.Hexdump(kvp.Value, context != contexts[1]);
}
TransferBuffer buffer = kvp.Key;
do
{
int count = context.Socket.Send(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None);
buffer.Offset += count;
Thread.Sleep(1);
} while (buffer.Offset != buffer.Size);
}
}
}
}
public void Start(string IP, ushort Port)
{
cl_security = new Security();
cl_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
cl_recv_buffer = new TransferBuffer(8192, 0, 0);
cl_packets = new List <Packet>();
SroClient.RemoteSecurity = cl_security;
//cl_socket.ReceiveTimeout = 5000;
//cl_socket.SendTimeout = 5000;
cl_socket.Connect(IP, Port);
cl_socket.NoDelay = true;
cl_socket.Blocking = false;
var thread = new Thread(ClientlessThread);
thread.Start();
if (!PingThread.IsAlive)
{
PingThread.Start();
}
}
static void AgentRemoteThread()
{
try
{
while (true)
{
lock (exit_lock)
{
if (should_exit)
{
break;
}
}
if (ag_remote_stream.DataAvailable)
{
ag_remote_recv_buffer.Offset = 0;
ag_remote_recv_buffer.Size = ag_remote_stream.Read(ag_remote_recv_buffer.Buffer, 0, ag_remote_recv_buffer.Buffer.Length);
ag_remote_security.Recv(ag_remote_recv_buffer);
}
ag_remote_recv_packets = ag_remote_security.TransferIncoming();
if (ag_remote_recv_packets != null)
{
foreach (Packet packet in ag_remote_recv_packets)
{
//print debug packet
//PrintDebugPacket(packet, TransferType.StoP, ProxyType.GW_RM);
// Do not pass through these packets.
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000)
{
continue;
}
PacketManager.Manager(packet);
ag_local_security.Send(packet);
}
}
ag_remote_send_buffers = ag_remote_security.TransferOutgoing();
if (ag_remote_send_buffers != null)
{
foreach (var kvp in ag_remote_send_buffers)
{
//print debug packet
//PrintDebugPacket(kvp.Value, TransferType.PtoS, ProxyType.GW_RM);
TransferBuffer buffer = kvp.Key;
try
{
ag_remote_stream.Write(buffer.Buffer, 0, buffer.Size);
}
catch (Exception ex)
{
PrintDebugPacket(kvp.Value, TransferType.PtoS, ProxyType.GW_RM);
Views.BindingFrom.WriteLine(String.Format("[AgentRemoteThread][ag_remote_stream] Exception: {0}" + Environment.NewLine, ex));
}
}
}
Thread.Sleep(1);
}
}
catch (Exception ex)
{
Views.BindingFrom.WriteLine(String.Format("[AgentRemoteThread] Exception: {0}" + Environment.NewLine, ex));
}
}
public void Allocate_Uninitialized_Fail(Device device, Type bufferType, int length)
{
using TransferBuffer <float> buffer = device.Get().AllocateTransferBuffer <float>(bufferType, length);
}
private void ClientlessThread()
{
try
{
while (true)
{
SocketError success;
Packet current;
cl_recv_buffer.Size = cl_socket.Receive(cl_recv_buffer.Buffer, 0, cl_recv_buffer.Buffer.Length, SocketFlags.None, out success);
if (success != SocketError.Success)
{
if (success != SocketError.WouldBlock)
{
Console.WriteLine("Disconnected!");
OnClientlessDisconnect?.Invoke();
return;
}
}
else if (cl_recv_buffer.Size > 0)
{
cl_security.Recv(cl_recv_buffer);
}
else
{
Console.WriteLine("Disconnected!!");
OnClientlessDisconnect?.Invoke();
return;
}
#region TransferIncoming
List <Packet> tmp = cl_security.TransferIncoming();
if (tmp != null)
{
cl_packets.AddRange(tmp);
}
if (cl_packets.Count > 0)
{
using (List <Packet> .Enumerator enumerator = cl_packets.GetEnumerator())
{
while (enumerator.MoveNext())
{
current = enumerator.Current;
Dispatcher.Process(current);
OnClientlessServerPacketReceive?.Invoke(current);
if (current.Opcode == 0x2001)
{
string module = current.ReadAscii();
if (module == "GatewayServer")
{
ServerStatus = PingStatus.Send; //Sets the ServerStatus to Gateway so the ping works correctly!
Packet p = new Packet(0x6100, true, false); //Patch request
p.WriteInt8(cl_Locale);
p.WriteAscii("SR_Client"); //Service name
p.WriteInt32(cl_GameVersion);
cl_security.Send(p);
}
else if (module == "AgentServer")
{
ServerStatus = PingStatus.Send;
Packet p = new Packet(0x6103, true, false); //Login packet
p.WriteUInt32(cl_SessionID); //Session ID we got from A102 Answer
p.WriteAscii(cl_Username);
p.WriteAscii(cl_Password);
p.WriteUInt8(cl_Locale);
p.WriteUInt32(0); //Mac address
p.WriteUInt16(0); //Mac address
cl_security.Send(p);
}
}
if (current.Opcode == 0xA102)
{
Console.WriteLine("Starting new connection to AgentServer!");
return;
}
}
}
cl_packets.Clear();
}
#endregion
#region TransferOutgoing
List <KeyValuePair <TransferBuffer, Packet> > tmp2 = cl_security.TransferOutgoing();
if (tmp2 != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> kvp in tmp2)
{
TransferBuffer key = kvp.Key;
OnClientlessClientPacketSent?.Invoke(kvp.Value);
success = SocketError.Success;
while (key.Offset != key.Size)
{
int num = cl_socket.Send(key.Buffer, key.Offset, key.Size - key.Offset, SocketFlags.None, out success);
if ((success != SocketError.Success) && (success != SocketError.WouldBlock))
{
break;
}
key.Offset += num;
Thread.Sleep(1);
}
if (success != SocketError.Success)
{
break;
}
}
}
#endregion
Thread.Sleep(1);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ex.StackTrace);
OnClientlessDisconnect?.Invoke();
}
}
/// <summary>
/// Throws a new <see cref="GraphicsDeviceMismatchException"/> instance from the specified parameters.
/// </summary>
/// <typeparam name="T">The type of values in the input buffer.</typeparam>
/// <param name="buffer">The input <see cref="TransferBuffer{T}"/> that was used.</param>
/// <param name="device">The target <see cref="GraphicsDevice"/> instance that was used.</param>
internal static void Throw <T>(TransferBuffer <T> buffer, GraphicsDevice device)
where T : unmanaged
{
throw Create(buffer, buffer.GraphicsDevice, device);
}
static void AgentRemoteThread()
{
try
{
while (true)
{
lock (exit_lock)
{
if (should_exit)
{
break;
}
}
if (ag_remote_stream.DataAvailable)
{
ag_remote_recv_buffer.Offset = 0;
ag_remote_recv_buffer.Size = ag_remote_stream.Read(ag_remote_recv_buffer.Buffer, 0, ag_remote_recv_buffer.Buffer.Length);
ag_remote_security.Recv(ag_remote_recv_buffer);
}
ag_remote_recv_packets = ag_remote_security.TransferIncoming();
if (ag_remote_recv_packets != null)
{
foreach (Packet packet in ag_remote_recv_packets)
{
//print debug packet
PrintDebugPacket(packet, TransferType.StoP, ProxyType.GW_RM);
// Do not pass through these packets.
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000)
{
continue;
}
PacketManagerClientless.Manager(packet);
#region
//Packet p;
//switch (packet.Opcode)
//{
// #region Login //ok
// case 0x2001://ok
// #region AGENT_SERVER = 0x2001
// string text = packet.ReadAscii();
// if (text == "AgentServer")
// {
// var packetLoginRequest = GeneratePacket.LoginRequest(Globals.clientInfo.Locale, Globals.loginUser, Globals.loginPass, Globals.session);
// ag_remote_security.Send(packetLoginRequest); // difference: this seds the packts that came from client to the server(remote)
// //continue;
// }
// #endregion
// break;
// case 0xA103://ok
// #region SERVER_AGENT_LOGIN_RESPONSE = 0xA103
// if (packet.ReadUInt8() == 1)
// {
// Packet response = new Packet(0x7007);//CLIENT_CHARACTERLISTING = 0x7007
// response.WriteUInt8(2);
// ag_remote_security.Send(response);
// //continue; //important so we can see chars #2
// }
// #endregion
// break;
// case 0xB007://ok
// #region CLIENT_AGENT_CHARACTER_SELECTION_REQUEST = 0xB007
// //List<string> characters = new List<string>();
// //SroBasicAuto.Logic.Login.GetCharacterList listChar = new Logic.Login.GetCharacterList();
// //characters = listChar.CharacterList(packet);
// //Globals.frmMain.listBox_char_Box.Invoke(
// // (MethodInvoker)(() => { Globals.frmMain.listBox_char_Box.Items.Clear(); }));
// //foreach (string sc in characters)
// //{
// // Globals.frmMain.listBox_char_Box.Invoke(
// // (MethodInvoker)(() => { Globals.frmMain.listBox_char_Box.Items.Add(sc); }));
// //}
// //Globals.frmMain.btn_selectChar.SetPropertyValue(a => a.Enabled, true);
// //continue; //this is the right important to see char
// #endregion
// break;
// case 0x3013://ok
// #region SERVER_AGENT_CHARACTER_DATA = 0x3013;
// //f1.Radar_refr.Start();
// //Globals.log("Sent Character.char_Packet = packet;");
// //CharData.char_Packet = packet;
// #endregion
// break;
// case 0xB624:
// if (packet.ReadUInt8() == 1)
// {
// //Globals.frmMain.btn_sendCaptcha.SetPropertyValue(a => a.Enabled, true);
// }
// break;
// #endregion
//}
#endregion
}
}
ag_remote_send_buffers = ag_remote_security.TransferOutgoing();
if (ag_remote_send_buffers != null)
{
foreach (var kvp in ag_remote_send_buffers)
{
//print debug packet
PrintDebugPacket(kvp.Value, TransferType.PtoS, ProxyType.GW_RM);
TransferBuffer buffer = kvp.Key;
ag_remote_stream.Write(buffer.Buffer, 0, buffer.Size);
}
}
Thread.Sleep(1);
}
}
catch (Exception ex)
{
Views.BindingFrom.WriteLine(String.Format("[AgentRemoteThread] Exception: {0}" + Environment.NewLine, ex));
}
}
/// <summary>
/// Tries to get the underlying COM object for a given resource, as a specified interface. This method invokes
/// <see href="https://docs.microsoft.com/windows/win32/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)">IUnknown::QueryInterface</see>.
/// </summary>
/// <typeparam name="T">The type of items stored on the buffer.</typeparam>
/// <param name="buffer">The input <see cref="TransferBuffer{T}"/> instance in use.</param>
/// <param name="riid">A reference to the interface identifier (IID) of the resource interface being queried for.</param>
/// <param name="ppvObject">The address of a pointer to an interface with the IID specified in <paramref name="riid"/>.</param>
/// <returns>
/// <c>S_OK</c> if the interface is supported, and <c>E_NOINTERFACE</c> otherwise.
/// If ppvObject (the address) is nullptr, then this method returns <c>E_POINTER</c>.
/// </returns>
public static int TryGetID3D12Resource <T>(TransferBuffer <T> buffer, Guid *riid, void **ppvObject)
where T : unmanaged
{
return(buffer.D3D12Resource->QueryInterface(riid, ppvObject));
}
private void AgentLocalThread()
{
try
{
while (this.local)
{
this.ag_local_recv_buffer.Offset = 0;
SocketError socketError;
this.ag_local_recv_buffer.Size = this.ag_local_client.Receive(this.ag_local_recv_buffer.Buffer, 0, this.ag_local_recv_buffer.Buffer.Length, SocketFlags.None, out socketError);
if (socketError != SocketError.Success)
{
if (socketError != SocketError.ConnectionReset)
{
if (socketError != SocketError.WouldBlock)
{
this.Disconnect(true);
break;
}
}
}
else
{
if (!this.ag_local_client.Connected)
{
this.Disconnect(false);
break;
}
else if (this.ag_local_recv_buffer.Size < 0)
{
this.Disconnect(false);
break;
}
this.ag_local_security.Recv(this.ag_local_recv_buffer);
}
this.ag_local_recv_packets = this.ag_local_security.TransferIncoming();
if (this.ag_local_recv_packets != null)
{
foreach (Packet packet in this.ag_local_recv_packets)
{
#region Packets
byte[] bytes = packet.GetBytes();
//Log.LogMsg("AG [C->S] " + packet.Opcode.ToString("X4") + " " + bytes.Length + " " + packet.Encrypted.ToString() + Environment.NewLine + Utility.HexDump(bytes) + Environment.NewLine);
int pLength = bytes.Length;
if (this.clientlessToClient && packet.Opcode == 0x7007)
{
byte type = packet.ReadUInt8();
if (type == 0x02)
{
Packet responseEndCS = new Packet(0xB001);
responseEndCS.WriteUInt8(0x01);
this.ag_local_security.Send(responseEndCS);
this.m_ClientWaitingForData = true;
this.currentSwitchActive = false;
Program.main.MainLog("Use ReturnScroll to finish Clientless->Client");
}
}
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001)
{
if (!this.ag_remote_client.Connected)
{
lock (this.login)
{
if (!this.agentIsConnected)
{
string ip = "127.0.0.1";
int port = Program.main.portSave;
if (this.clientlessToClient || Program.main.mBot)
{
port = Program.main.getFreeBotPort(true);
}
if (Program.main.checkBox_manualPortOverride.Checked)
{
port = Convert.ToInt32(Program.main.textBox_manualPortOverride.Text);
}
if (port != 0)
{
this.agentIsConnected = true;
this.ag_remote_client.Connect(ip, port);
this.ag_remote_client.Blocking = false;
this.ag_remote_client.NoDelay = true;
remoteThread = new Thread(new ThreadStart(AgentRemoteThread));
remoteThread.Start();
}
else
{
Program.main.MainLog("Not free BotPort found - Agent");
}
}
}
}
if (packet.Opcode == 0x2001 && this.clientlessToClient)
{
Packet response = new Packet(0x2001);
response.WriteAscii("AgentServer");
response.WriteUInt8(0);
response.Lock();
this.ag_local_security.Send(response);
if (Program.main.localeSave == Utility.SilkroadLocale.VSRO)
{
response = new Packet(0x2005, false, true);
response.WriteUInt8(0x01);
response.WriteUInt8(0x00);
response.WriteUInt8(0x01);
response.WriteUInt8(0xBA);
response.WriteUInt8(0x02);
response.WriteUInt8(0x05);
response.WriteUInt8(0x00);
response.WriteUInt8(0x00);
response.WriteUInt8(0x00);
response.WriteUInt8(0x02);
response.Lock();
this.ag_local_security.Send(response);
response = new Packet(0x6005, false, true);
response.WriteUInt8(0x03);
response.WriteUInt8(0x00);
response.WriteUInt8(0x02);
response.WriteUInt8(0x00);
response.WriteUInt8(0x02);
response.Lock();
this.ag_local_security.Send(response);
}
}
}
else if (!this.clientlessToClient || this.currentSwitchActive)
{
if (packet.Opcode == 0x6103)
{
lock (this.login)
{
if (!this._a103Sent)
{
this._a103Sent = true;
if (Program.main.localeSave == Utility.SilkroadLocale.VSRO)
{
Packet p = new Packet(0xA103, true);
p.WriteUInt8(1);
this.ag_local_security.Send(p);
}
else if (Program.main.localeSave == Utility.SilkroadLocale.TRSRO)
{
Packet p = new Packet(0xA103, true);
p.WriteUInt8(1);
p.WriteUInt8(3);
p.WriteUInt8(0);
this.ag_local_security.Send(p);
}
}
}
}
this.ag_remote_security.Send(packet);
}
#endregion
}
}
#region Outgoing Packetx
this.ag_local_send_buffers = this.ag_local_security.TransferOutgoing();
if (this.ag_local_send_buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> current in this.ag_local_send_buffers)
{
Packet packet = current.Value;
if (!this.clientlessToClient || (this.currentSwitchActive || packet.Opcode == 0xB001))
{
TransferBuffer key = current.Key;
while (key.Offset != key.Size)
{
this.ag_local_client.Blocking = true;
int num4 = this.ag_local_client.Send(key.Buffer, key.Offset, key.Size - key.Offset, SocketFlags.None);
this.ag_local_client.Blocking = false;
key.Offset += num4;
}
}
}
}
#endregion
Thread.Sleep(1);
}
}
catch
{
this.Disconnect(false);
}
}
private void ThreadGateway()
{
Gateway = new Gateway(this.SelectHost(), this.SelectPort());
Window w = Window.Get;
Socket SocketBinded = BindGatewaySocket("127.0.0.1", 20190);
if (!LoginClientlessMode)
{
Gateway.Local.Socket = SocketBinded;
try
{
// Loader setup
w.LogProcess("Executing EdxLoader...");
EdxLoader loader = new EdxLoader(DataManager.ClientPath);
loader.SetPatches(true, true, false);
sro_client = loader.StartClient(false, DataManager.Locale, 0, lastHostIndexSelected, ((IPEndPoint)Gateway.Local.Socket.LocalEndPoint).Port);
if (sro_client == null)
{
Stop();
}
else
{
sro_client.PriorityClass = ProcessPriorityClass.AboveNormal;
}
int dummy = 0;
w.Log("Waiting for client connection [" + Gateway.Local.Socket.LocalEndPoint.ToString() + "]");
w.LogProcess("Waiting client connection...", Window.ProcessState.Warning);
// Wait 2min. Infinity attempts
ProxyReconnection(120, ref dummy, int.MaxValue);
Gateway.Local.Socket = Gateway.Local.Socket.Accept();
ProxyReconnectionStop();
w.LogProcess("Connected");
// Save client process
sro_client.EnableRaisingEvents = true;
sro_client.Exited += new EventHandler(this.Client_Closed);
}
catch {
w.LogProcess();
return;
}
}
try
{
Gateway.Remote.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
w.Log("Connecting to Gateway server [" + Gateway.Host + ":" + Gateway.Port + "]");
w.LogProcess("Waiting server connection...");
ProxyReconnection(30, ref CurrentAttemptReconnections, 10); // Wait 30 seconds, max. 10 attempts
Gateway.Remote.Socket.Connect(Gateway.Host, Gateway.Port);
ProxyReconnectionStop();
CurrentAttemptReconnections = 0;
w.Log("Connected");
w.LogProcess("Connected");
}
catch { return; }
try
{
// Handle it easily by iterating
List <Context> gws = new List <Context>();
gws.Add(Gateway.Remote);
if (!ClientlessMode)
{
gws.Add(Gateway.Local);
}
PingHandler = new Thread(ThreadPing);
PingHandler.Start();
// Running process
while (isRunning)
{
// Network input event processing
foreach (Context context in gws)
{
if (context.Socket.Poll(0, SelectMode.SelectRead))
{
int count = context.Socket.Receive(context.Buffer.Buffer);
if (count == 0)
{
throw new Exception("The remote connection has been lost.");
}
context.Security.Recv(context.Buffer.Buffer, 0, count);
}
}
// Logic event processing
foreach (Context context in gws)
{
List <Packet> packets = context.Security.TransferIncoming();
if (packets != null)
{
foreach (Packet packet in packets)
{
// Show all incoming packets on analizer
if (context == Gateway.Remote && w.Settings_cbxShowPacketServer.Checked)
{
bool opcodeFound = false;
WinAPI.InvokeIfRequired(w.Settings_lstvOpcodes, () => {
opcodeFound = w.Settings_lstvOpcodes.Items.ContainsKey(packet.Opcode.ToString());
});
if (opcodeFound && w.Settings_rbnPacketOnlyShow.Checked ||
!opcodeFound && !w.Settings_rbnPacketOnlyShow.Checked)
{
w.LogPacket(string.Format("[G][{0}][{1:X4}][{2} bytes]{3}{4}{6}{5}", "S->C", packet.Opcode, packet.GetBytes().Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Utility.HexDump(packet.GetBytes()), Environment.NewLine));
}
}
// Switch from gateway to agent process
if (packet.Opcode == Gateway.Opcode.SERVER_LOGIN_RESPONSE)
{
byte result = packet.ReadByte();
if (result == 1)
{
// Stop ping while switch
PingHandler.Abort();
Agent = new Agent(packet.ReadUInt(), packet.ReadAscii(), packet.ReadUShort());
// Bind socket available
string agentHost = ((IPEndPoint)SocketBinded.LocalEndPoint).Address.ToString();
int agentPort = ((IPEndPoint)SocketBinded.LocalEndPoint).Port + 1;
Thread agThread = new Thread(() => {
ThreadAgent(agentHost, agentPort);
});
agThread.Priority = ThreadPriority.AboveNormal;
agThread.Start();
// Proxy packet (bot listeninig)
PacketBuilder.Client.CreateAgentLogin(result, Agent.id, agentHost, (ushort)agentPort);
}
else if (result == 2)
{
byte error = packet.ReadByte();
switch (error)
{
case 1:
{
uint maxAttempts = packet.ReadUInt();
uint attempts = packet.ReadUInt();
w.Log("Password entry has failed (" + attempts + " / " + maxAttempts + " attempts)");
w.LogProcess("Password failed", Window.ProcessState.Warning);
break;
}
case 2:
byte blockType = packet.ReadByte();
if (blockType == 1)
{
string blockedReason = packet.ReadAscii();
ushort endYear = packet.ReadUShort();
ushort endMonth = packet.ReadUShort();
ushort endDay = packet.ReadUShort();
ushort endHour = packet.ReadUShort();
ushort endMinute = packet.ReadUShort();
ushort endSecond = packet.ReadUShort();
w.Log("Account banned till [" + endDay + "/" + endMonth + "/" + endYear + " " + endHour + "/" + endMinute + "/" + endSecond + "]. Reason: " + blockedReason);
w.LogProcess("Account banned", Window.ProcessState.Error);
}
break;
case 3:
w.Log("This user is already connected. Please try again in 5 minutes");
break;
default:
w.Log("Login error [" + error + "]");
break;
}
// Client bugfix reset
Bot.Get.LoggedFromBot = false;
w.Login_btnStart.InvokeIfRequired(() => {
w.Login_btnStart.Enabled = true;
});
context.RelaySecurity.Send(packet);
}
}
else if (!Gateway.PacketHandler(context, packet) &&
!Gateway.IgnoreOpcode(packet.Opcode, context))
{
// Send normally through proxy
context.RelaySecurity.Send(packet);
}
}
}
}
// Network output event processing
foreach (Context context in gws)
{
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
List <KeyValuePair <TransferBuffer, Packet> > buffers = context.Security.TransferOutgoing();
if (buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> kvp in buffers)
{
TransferBuffer buffer = kvp.Key;
Packet packet = kvp.Value;
byte[] packet_bytes = packet.GetBytes();
// Show outcoming packets on analizer
if (context == Gateway.Remote && w.Settings_cbxShowPacketClient.Checked)
{
bool opcodeFound = false;
WinAPI.InvokeIfRequired(w.Settings_lstvOpcodes, () => {
opcodeFound = w.Settings_lstvOpcodes.Items.ContainsKey(packet.Opcode.ToString());
});
if (opcodeFound && w.Settings_rbnPacketOnlyShow.Checked ||
!opcodeFound && !w.Settings_rbnPacketOnlyShow.Checked)
{
w.LogPacket(string.Format("[G][{0}][{1:X4}][{2} bytes]{3}{4}{6}{5}", "C->S", packet.Opcode, packet.GetBytes().Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Utility.HexDump(packet.GetBytes()), Environment.NewLine));
}
}
while (true)
{
int count = context.Socket.Send(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None);
buffer.Offset += count;
if (buffer.Offset == buffer.Size)
{
break;
}
}
}
}
}
}
Thread.Sleep(1); // Cycle complete, prevent 100% CPU usage
}
}
catch (Exception ex)
{
CloseGateway();
w.LogPacket("[G] Error: " + ex.Message);
// Check if agent it's not running
if (Agent == null)
{
Stop();
}
}
}
static void Clientless_Start(Context context)
{
//Clientless started, start the ping thread.
var keepalive = new Thread(() => Clientless_Ping(context));
keepalive.Start();
try
{
while (true)
{
if (context.Socket.Poll(0, SelectMode.SelectRead))
{
int count = context.Socket.Receive(context.Buffer.Buffer);
if (count == 0)
{
Console.WriteLine("Null received, Disconnected!");
OnProxyDisconnect?.Invoke();
}
context.Security.Recv(context.Buffer.Buffer, 0, count);
}
List <Packet> packets = context.Security.TransferIncoming();
if (packets != null)
{
foreach (Packet packet in packets)
{
Dispatcher.Process(new Packet(packet));
OnProxyServerPacketReceive?.Invoke(packet);
if (packet.Opcode == 0x34B5) //Character teleport successfully
{
Packet answer = new Packet(0x34B6); //Teleport confirmation packet
context.Security.Send(answer);
}
}
}
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
List <KeyValuePair <TransferBuffer, Packet> > buffers = context.Security.TransferOutgoing();
if (buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> kvp in buffers)
{
TransferBuffer buffer = kvp.Key;
OnProxyClientPacketSent?.Invoke(kvp.Value);
while (true)
{
int count = context.Socket.Send(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None);
buffer.Offset += count;
if (buffer.Offset == buffer.Size)
{
break;
}
Thread.Sleep(1);
}
}
}
}
}
} catch
{
Console.WriteLine("Disconnected!");
OnProxyDisconnect?.Invoke();
}
}
static void GatewayLocalThread()
{
try
{
while (true)
{
lock (exit_lock)
{
if (should_exit)
{
break;
}
}
if (gw_local_stream.DataAvailable)
{
gw_local_recv_buffer.Offset = 0;
gw_local_recv_buffer.Size = gw_local_stream.Read(gw_local_recv_buffer.Buffer, 0, gw_local_recv_buffer.Buffer.Length);
gw_local_security.Recv(gw_local_recv_buffer);
}
gw_local_recv_packets = gw_local_security.TransferIncoming();
if (gw_local_recv_packets != null)
{
#region gw_local_recv_packets
gw_local_recv_packets.ForEach(delegate(Packet packet)
{
byte[] packet_bytes = packet.GetBytes();
// Do not pass through these packets.
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001)
{
return;
}
//print log
PrintDebugPacket(packet, TransferType.CtoP, ProxyType.GW_LC);
gw_remote_security.Send(packet);
});
#endregion
}
#region gw_local_send_buffers
gw_local_send_buffers = gw_local_security.TransferOutgoing();
if (gw_local_send_buffers != null)
{
gw_local_send_buffers.ForEach(delegate(KeyValuePair <TransferBuffer, Packet> kvp)
{
Packet packet = kvp.Value;
TransferBuffer buffer = kvp.Key;
//byte[] packet_bytes = packet.GetBytes();
//Print log
//if (!IgnoreOpcodes.Contains(packet.Opcode))
//Views.BindingFrom.WriteLine(String.Format("[P->C][GW_LC][{0:X4}][{1} bytes]{2}{3}{4}{5}", packet.Opcode, packet_bytes.Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Environment.NewLine, Utility.HexDump(packet_bytes)));
//PrintDebugPacket(packet, TransferType.PtoC, ProxyType.GW_LC);
gw_local_stream.Write(buffer.Buffer, 0, buffer.Size);
});
}
#endregion
Thread.Sleep(1);
}
}
catch (System.Exception ex)
{
Views.BindingFrom.Write("[ERROR] [GatewayProxy::GatewayLocalThread]");
Views.BindingFrom.WriteLine(ex.Message);
}
}
public static void UDPProxy(string remoteIP, int remotePort, int localPort)
{
List <Context> contexts = new List <Context>();
Context local_context = new Context(new TempUDPSecurity());
Context remote_context = new Context(new TempUDPSecurity());
local_context.RelaySecurity = remote_context.Security;
remote_context.RelaySecurity = local_context.Security;
EndPoint local_recv_endpoint = new IPEndPoint(IPAddress.Loopback, localPort);
EndPoint remote_recv_endpoint = new IPEndPoint(IPAddress.Parse(remoteIP), remotePort);
contexts.Add(local_context);
contexts.Add(remote_context);
Console.WriteLine("Initializing UDP Proxy.");
using (local_context.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
local_context.Socket.Bind(local_recv_endpoint);
using (remote_context.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
remote_context.Socket.Connect(remote_recv_endpoint);
while (true)
{
#region TransferIncoming
//Receive packets from local and remote contexts.
ProxyTransferIncoming(contexts);
foreach (var context in contexts)
{
foreach (var packet in context.Security.TransferIncoming())
{
if (dumpUDP)
{
Utility.Hexdump(packet, context == remote_context, true);
}
context.RelaySecurity.Send(packet);
}
}
#endregion
#region TransferOutgoing
foreach (var context in contexts)
{
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
foreach (var kvp in context.Security.TransferOutgoing())
{
TransferBuffer buffer = kvp.Key;
int count = 0;
if (context == remote_context)
{
count = context.Socket.SendTo(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None, remote_recv_endpoint);
}
else
{
count = context.Socket.SendTo(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None, local_recv_endpoint);
}
Thread.Sleep(1);
}
}
}
#endregion
Thread.Sleep(1);
}
}
}
}
public static void UdpClientless(string remoteIP, int remotePort)
{
Context context = new Context(new UDPSecurity());
RemoteUDPContext = context;
context.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
EndPoint serv_endpoint = new IPEndPoint(IPAddress.Parse(remoteIP), remotePort);
bool sentData = false;
using (context.Socket)
{
context.Socket.Connect(serv_endpoint);
var p1 = new Packet(0x02, 0x03);
p1.WriteUInt32(uniquePlayerID);
p1.WriteUInt8Array(new byte[] { 0xC0, 0xA8, 0x01, 0xC9, 0x00, 0x00 });
SendUDPPacket(p1);
while (true)
{
if (!TCPTransferIngoingPackets(context))
{
break;
}
foreach (var packet in context.Security.TransferIncoming())
{
if (packet.Opcode == 0x00)
{
var b = packet.GetBytes();
if (b.Length == 0x05 && b.SequenceEqual(new byte[] { 0x0D, 0x00, 0x70, 0x00, 0x00 }))
{
Console.WriteLine("SENT 70 PACKET");
SendUDPPacket(packet);
var p = new Packet(0x02, 0x04);
p.WriteUInt32(uniquePlayerID);
p.WriteUInt8Array(zero2zero3);
SendTCPPacket(p);
}
else if (b.Length == 0x05 && b.SequenceEqual(new byte[] { 0x0D, 0x00, 0x60, 0x10, 0x00 }))
{
var p = new Packet(0x0C, 0x07, new byte[] { 0x00, 0x00, 0x00, 0x00, 0x1F, 0x27, 0x00, 0x00 });
SendUDPPacket(p);
p = new Packet(0x0C, 0x01);
p.WriteUInt32(uniquePlayerID);
SendUDPPacket(p);
}
}
else if (packet.Opcode1 == 0x07 && packet.Opcode2 == 0x74 && !sentData)
{
sendudpdata();
sentData = true;
}
else if (packet.Opcode1 == 0x06 && packet.Opcode2 == 0x0B && !sentData)
{
sendudpdata();
sentData = true;
}
Console.WriteLine("[UDP]");
Utility.Hexdump(packet, true);
}
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
foreach (var kvp in context.Security.TransferOutgoing())
{
Utility.Hexdump(kvp.Value, false);
TransferBuffer buffer = kvp.Key;
int count = context.Socket.SendTo(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None, serv_endpoint);
}
}
Thread.Sleep(1);
}
}
}
private void AgentRemoteThread()
{
while (this.remote)
{
try
{
this.ag_remote_recv_buffer.Offset = 0;
SocketError socketError;
try
{
this.ag_remote_recv_buffer.Size = this.ag_remote_client.Receive(this.ag_remote_recv_buffer.Buffer, 0, this.ag_remote_recv_buffer.Buffer.Length, SocketFlags.None, out socketError);
if (socketError != SocketError.Success)
{
if (socketError != SocketError.WouldBlock)
{
this.Disconnect(false);
break;
}
}
else
{
if (!this.ag_remote_client.Connected || this.ag_remote_recv_buffer.Size <= 0)
{
this.Disconnect(true);
break;
}
this.ag_remote_security.Recv(this.ag_remote_recv_buffer);
}
}
catch
{
this.Disconnect(false);
}
try
{
this.ag_remote_recv_packets = this.ag_remote_security.TransferIncoming();
}
catch
{
this.Disconnect(false);
}
if (this.ag_remote_recv_packets != null)
{
foreach (Packet packet in this.ag_remote_recv_packets)
{
byte[] bytes = packet.GetBytes();
//Log.LogMsg("AG [S->C] " + packet.Opcode.ToString("X4") + " " + bytes.Length + " " + packet.Encrypted.ToString() + Environment.NewLine + Utility.HexDump(bytes) + Environment.NewLine);
#region FakeClient
if (this.clientlessToClient)
{
if (packet.Opcode == 0x30D2)
{
while (this.m_ClientWaitingForData == false && this.m_ClientWatingForFinish == false)
{
System.Threading.Thread.Sleep(1);
}
//Client is ready
if (this.m_ClientWaitingForData)
{
this.currentSwitchActive = true;
//Accept Teleport
Packet respone = new Packet(0x34B6);
this.ag_remote_security.Send(respone);
this.m_ClientWatingForFinish = true;
this.m_ClientWaitingForData = false;
//!!! CrossThreading!!!
Program.main.MainLog("Waiting to finish teleport");
}
}
//Incoming CharacterData
if (packet.Opcode == 0x34A5)
{
if (this.m_ClientWatingForFinish)
{
this.clientlessToClient = false;
this.m_ClientWatingForFinish = false;
//!!! CrossThreading!!!
Program.main.MainLog("Successfully switched");
}
}
}
#endregion
if (packet.Opcode != 0x5000 && packet.Opcode != 0x9000)
{
if (packet.Opcode == 0xA103)
{
lock (this.login)
{
if (!this._a103Sent)
{
this._a103Sent = true;
}
else
{
continue;
}
}
}
if (!this.clientlessToClient)
{
this.ag_local_security.Send(packet);
}
}
}
}
#region Outgoing Packets
try
{
this.ag_remote_send_buffers = this.ag_remote_security.TransferOutgoing();
if (this.ag_remote_send_buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> current2 in this.ag_remote_send_buffers)
{
Packet packet = current2.Value;
byte[] bytes = packet.GetBytes();
if (!this.clientlessToClient || this.currentSwitchActive)
{
TransferBuffer key = current2.Key;
while (key.Offset != key.Size)
{
this.ag_remote_client.Blocking = true;
int num6 = this.ag_remote_client.Send(key.Buffer, key.Offset, key.Size - key.Offset, SocketFlags.None);
this.ag_remote_client.Blocking = false;
key.Offset += num6;
Thread.Sleep(1);
}
}
}
}
Thread.Sleep(1);
}
catch (Exception e)
{
Log.LogEx(e);
this.Disconnect(true);
}
#endregion
}
catch (Exception e)
{
Log.LogEx(e);
this.Disconnect(false);
}
Thread.Sleep(5);
}
}
/// <summary>
/// Creates a new <see cref="MemoryManager"/> instance for a given buffer.
/// </summary>
/// <param name="buffer">The <see cref="TransferBuffer{T}"/> in use.</param>
public MemoryManager(TransferBuffer <T> buffer)
{
this.buffer = buffer;
}
public static void StartProxy(string remote_ip, ushort remote_port, string local_ip, ushort local_port) //Pushedx proxy.
{
Client.RefreshClient();
ConnectedToWorldwideServer = false;
Context local_context = new Context();
local_context.Security.GenerateSecurity(true, true, true);
Context remote_context = new Context();
SroClient.RemoteSecurity = remote_context.Security;
SroClient.LocalSecurity = local_context.Security;
remote_context.RelaySecurity = local_context.Security;
local_context.RelaySecurity = remote_context.Security;
List <Context> contexts = new List <Context>();
contexts.Add(local_context);
contexts.Add(remote_context);
using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
server.Bind(new IPEndPoint(IPAddress.Parse(local_ip), local_port));
server.Listen(1);
local_context.Socket = server.Accept();
}
using (local_context.Socket)
{
using (remote_context.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
remote_context.Socket.Connect(remote_ip, remote_port);
while (true)
{
#region TransferIncoming
foreach (Context context in contexts) // Network input event processing
{
try
{
if (context.Socket.Poll(0, SelectMode.SelectRead))
{
int count = context.Socket.Receive(context.Buffer.Buffer);
if (count == 0)
{
Console.WriteLine("Null recevied, disconnected");
OnProxyDisconnect?.Invoke();
throw new Exception("The remote connection has been lost.");
}
context.Security.Recv(context.Buffer.Buffer, 0, count);
}
}
catch (Exception ex)
{
//If local context disconnects && the account is connected to agent server > switch clientless
if (context == local_context && ConnectedToWorldwideServer == true && AutoSwitchToClientless)
{
OnProxyClientlessStart?.Invoke();
Clientless_Start(remote_context);
}
return;
}
}
foreach (Context context in contexts) // Logic event processing
{
List <Packet> packets = context.Security.TransferIncoming();
if (packets != null)
{
foreach (Packet packet in packets)
{
Dispatcher.Process(new Packet(packet));
OnProxyServerPacketReceive?.Invoke(new Packet(packet));
if (packet.Opcode == 0xB001)
{
ConnectedToWorldwideServer = true;
}
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000) // ignore always
{
}
else if (packet.Opcode == 0x2001)
{
if (context == remote_context) // ignore local to proxy only
{
context.RelaySecurity.Send(packet); // proxy to remote is handled by API
}
}
else if (packet.Opcode == 0xA102)
{
byte result = packet.ReadUInt8();
if (result == 1)
{
SessionID = packet.ReadUInt32();
string ip = packet.ReadAscii();
ushort port = packet.ReadUInt16();
var agentThread = new Thread(() => StartProxy(ip, ushort.Parse((port).ToString()), local_ip, local_port));
agentThread.Start();
Thread.Sleep(500);
//Fake response to redirect the client.
Packet new_packet = new Packet(0xA102, true);
new_packet.WriteUInt8(result);
new_packet.WriteUInt32(SessionID);
new_packet.WriteAscii(local_ip);
new_packet.WriteUInt16(local_port);
context.RelaySecurity.Send(new_packet);
}
else
{
context.RelaySecurity.Send(packet);
}
}
else if (packet.Opcode == 0x6103)
{
//If the client is sending 0x6103 agent auth packet, don't relay it
//because we send our own.
}
else
{
context.RelaySecurity.Send(packet);
}
}
}
}
#endregion
#region TransferOutgoing
foreach (Context context in contexts) // Network output event processing
{
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
List <KeyValuePair <TransferBuffer, Packet> > buffers = context.Security.TransferOutgoing();
if (buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> kvp in buffers)
{
TransferBuffer buffer = kvp.Key;
OnProxyClientPacketSent?.Invoke(kvp.Value);
//Save locale, username, password
if (kvp.Value.Opcode == 0x6102)
{
var p = new Packet(kvp.Value);
Locale = p.ReadUInt8();
Username = p.ReadAscii();
Password = p.ReadAscii();
}
//if the remote server signals switching to agent, send the auth packet.
else if (kvp.Value.Opcode == 0x2001)
{
if (kvp.Value.ReadAscii() == "AgentServer")
{
Packet p = new Packet(0x6103, true, false); //Login packet
p.WriteUInt32(SessionID); //Session ID we got from A102 Answer
p.WriteAscii(Username);
p.WriteAscii(Password);
p.WriteUInt8(Locale);
p.WriteUInt32(0); //Mac address
p.WriteUInt16(0); //Mac address
remote_context.Security.Send(p);
}
}
while (true)
{
int count = context.Socket.Send(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None);
buffer.Offset += count;
if (buffer.Offset == buffer.Size)
{
break;
}
Thread.Sleep(1);
}
}
}
}
}
#endregion
Thread.Sleep(1); // Cycle complete, prevent 100% CPU usage
}
}
}
}
static void AgentLocalThread()
{
try
{
while (true)
{
lock (exit_lock)
{
if (should_exit)
{
break;
}
}
if (ag_local_stream.DataAvailable)
{
ag_local_recv_buffer.Offset = 0;
ag_local_recv_buffer.Size = ag_local_stream.Read(ag_local_recv_buffer.Buffer, 0, ag_local_recv_buffer.Buffer.Length);
ag_local_security.Recv(ag_local_recv_buffer);
}
ag_local_recv_packets = ag_local_security.TransferIncoming();
if (ag_local_recv_packets != null)
{
#region ag_local_recv_packets
ag_local_recv_packets.ForEach(delegate(Packet packet)
{
byte[] packet_bytes = packet.GetBytes();
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001)
{
return;
}
//print log
//if (!IgnoreOpcodes.Contains(packet.Opcode))
// Views.BindingView.Write(String.Format("[C->P][AG_LC][{0:X4}][{1} bytes]{2}{3}{4}{5}", packet.Opcode, packet_bytes.Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Environment.NewLine, Utility.HexDump(packet_bytes)));
switch (packet.Opcode)
{
case 0x7158: //resert when after upskill
//int flag = packet.ReadUInt8();
//if (flag == 1)
//{
// packet.ReadUInt8();//unk
// flag = packet.ReadUInt8();
// if (flag == 73)
// {
// uint iskillId = packet.ReadUInt32();
// var skillTemp = CharData.Skill.FirstOrDefault(a => a.id.Equals(iskillId));
// if (skillTemp != null && skillTemp.id != 0 && skillTemp.status == 1)
// {
// if (skillTemp.type.Contains("_PASSIVE_"))//skill passive
// { }
// else if (skillTemp.type.Contains("_GIGONGTA_")) //skill imbue
// { }
// else
// {
// if (skillTemp.type.StartsWith("SKILL_CH_BOW") || skillTemp.type.StartsWith("SKILL_CH_SPEAR")
// || skillTemp.type.StartsWith("SKILL_CH_SWORD"))
// {
// if (skillTemp.type.StartsWith("SKILL_CH_BOW_CALL") || skillTemp.type.StartsWith("SKILL_CH_BOW_NORMAL")
// || skillTemp.type.StartsWith("SKILL_CH_SPEAR_SPIN") || skillTemp.type.StartsWith("SKILL_CH_SWORD_SHIELD"))
// {
// skillTemp.status = 0;
// }
// }
// if (skillTemp.type.StartsWith("SKILL_CH_COLD") || skillTemp.type.StartsWith("SKILL_CH_LIGHTNING")
// || skillTemp.type.StartsWith("SKILL_CH_FIRE"))
// {
// if (skillTemp.type.Contains("_GIGONGSUL_") || skillTemp.type.StartsWith("SKILL_CH_LIGHTNING_STORM")
// || skillTemp.type.StartsWith("SKILL_CH_LIGHTNING_CHUNDUNG") || skillTemp.type.StartsWith("SKILL_CH_COLD_BINGPAN"))
// { }
// else//skill buff
// {
// skillTemp.status = 0;
// }
// }
// }
// }
// }
//}
break;
}
ag_remote_security.Send(packet);
});
#endregion
}
#region ag_local_send_buffers
ag_local_send_buffers = ag_local_security.TransferOutgoing();
if (ag_local_send_buffers != null)
{
ag_local_send_buffers.ForEach((kvp) =>
{
Packet packet = kvp.Value;
TransferBuffer buffer = kvp.Key;
byte[] packet_bytes = packet.GetBytes();
//print log
//if (!IgnoreOpcodes.Contains(packet.Opcode))
// Log.Write(String.Format("[P->C][AG_LC][{0:X4}][{1} bytes]{2}{3}{4}{5}", packet.Opcode, packet_bytes.Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Environment.NewLine, Utility.HexDump(packet_bytes)));
ag_local_stream.Write(buffer.Buffer, 0, buffer.Size);
});
}
#endregion
Thread.Sleep(1);
}
}
catch (System.Exception ex)
{
Views.BindingFrom.Write("[ERROR] [AgentProxy::AgentLocalThread]");
Views.BindingFrom.WriteLine(ex.Message);
}
}
private void ThreadAgent(string Host, int Port)
{
Window w = Window.Get;
// Connect AgentClient to Proxy
if (!ClientlessMode)
{
Agent.Local.Socket = BindSocket(Host, Port);
try
{
int dummy = 0;
w.LogProcess("Waiting client connection...", Window.ProcessState.Warning);
ProxyReconnection(10, ref dummy, int.MaxValue);
Agent.Local.Socket = Agent.Local.Socket.Accept();
ProxyReconnectionStop();
w.LogProcess("Connected");
}
catch { return; }
}
Agent.Remote.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
int dummy = 0;
w.Log("Connecting to Agent server [" + Agent.Host + ":" + Agent.Port + "]");
w.LogProcess("Waiting server connection...");
ProxyReconnection(10, ref dummy, int.MaxValue);
Agent.Remote.Socket.Connect(Agent.Host, Agent.Port);
ProxyReconnectionStop();
w.Log("Connected");
w.LogProcess("Connected");
}
catch
{
w.Log("Failed to connect to the server");
w.LogProcess();
return;
}
try
{
// Handle it easily by iterating
List <Context> ags = new List <Context>();
ags.Add(Agent.Remote);
if (!ClientlessMode)
{
ags.Add(Agent.Local);
}
PingHandler = new Thread(ThreadPing);
PingHandler.Start();
while (isRunning)
{
// Network input event processing
foreach (Context context in ags)
{
if (context.Socket.Poll(0, SelectMode.SelectRead))
{
try
{
int count = context.Socket.Receive(context.Buffer.Buffer);
if (count == 0)
{
throw new Exception("The remote connection has been lost.");
}
context.Security.Recv(context.Buffer.Buffer, 0, count);
}
catch (Exception ex) {
if (context == Agent.Local)
{
// Try to continue without client
ags.Remove(context);
break;
}
else
{
throw ex;
}
}
}
}
// Logic event processing
foreach (Context context in ags)
{
List <Packet> packets = context.Security.TransferIncoming();
if (packets != null)
{
foreach (Packet packet in packets)
{
// Show all incoming packets on analizer
if (context == Agent.Remote && w.Settings_cbxShowPacketServer.Checked)
{
bool opcodeFound = false;
WinAPI.InvokeIfRequired(w.Settings_lstvOpcodes, () => {
opcodeFound = w.Settings_lstvOpcodes.Items.ContainsKey(packet.Opcode.ToString());
});
if (opcodeFound && w.Settings_rbnPacketOnlyShow.Checked ||
!opcodeFound && !w.Settings_rbnPacketOnlyShow.Checked)
{
w.LogPacket(string.Format("[A][{0}][{1:X4}][{2} bytes]{3}{4}{6}{5}", "S->C", packet.Opcode, packet.GetBytes().Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Utility.HexDump(packet.GetBytes()), Environment.NewLine));
}
}
if (!Agent.PacketHandler(context, packet) && !Agent.IgnoreOpcode(packet.Opcode, context))
{
// Send normally through proxy
context.RelaySecurity.Send(packet);
}
}
}
}
// Network output event processing
foreach (Context context in ags)
{
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
List <KeyValuePair <TransferBuffer, Packet> > buffers = context.Security.TransferOutgoing();
if (buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> kvp in buffers)
{
TransferBuffer buffer = kvp.Key;
Packet packet = kvp.Value;
byte[] packet_bytes = packet.GetBytes();
// Show outcoming packets on analizer
if (context == Agent.Remote && w.Settings_cbxShowPacketClient.Checked)
{
bool opcodeFound = false;
w.Settings_lstvOpcodes.InvokeIfRequired(() => {
opcodeFound = w.Settings_lstvOpcodes.Items.ContainsKey(packet.Opcode.ToString());
});
if (opcodeFound && w.Settings_rbnPacketOnlyShow.Checked ||
!opcodeFound && !w.Settings_rbnPacketOnlyShow.Checked)
{
w.LogPacket(string.Format("[A][{0}][{1:X4}][{2} bytes]{3}{4}{6}{5}", "C->S", packet.Opcode, packet.GetBytes().Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Utility.HexDump(packet.GetBytes()), Environment.NewLine));
}
}
while (true)
{
int count;
try
{
count = context.Socket.Send(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None);
}
catch (Exception ex)
{
if (context == Agent.Local)
{
// Try to continue without send to client
break;
}
else
{
throw ex;
}
}
buffer.Offset += count;
if (buffer.Offset == buffer.Size)
{
break;
}
}
}
}
}
}
Thread.Sleep(1); // Cycle complete, prevent 100% CPU usage
}
}
catch (Exception ex)
{
w.LogPacket("[A] Error: " + ex.Message + Environment.NewLine);
Stop();
}
}
private void GatewayLocalThread()
{
try
{
while (this.local)
{
this.gw_local_recv_buffer.Offset = 0;
SocketError socketError;
this.gw_local_recv_buffer.Size = this.gw_local_client.Receive(this.gw_local_recv_buffer.Buffer, 0, this.gw_local_recv_buffer.Buffer.Length, SocketFlags.None, out socketError);
if (socketError != SocketError.Success)
{
if (socketError != SocketError.WouldBlock)
{
this.CleanClient();
break;
}
}
else
{
if (!this.gw_local_client.Connected || this.gw_local_recv_buffer.Size <= 0)
{
this.CleanClient();
break;
}
this.gw_local_security.Recv(this.gw_local_recv_buffer);
}
this.gw_local_recv_packets = this.gw_local_security.TransferIncoming();
if (this.gw_local_recv_packets != null)
{
foreach (Packet packet in this.gw_local_recv_packets)
{
byte[] bytes = packet.GetBytes();
//Log.LogMsg("GW [C->S] " + packet.Opcode.ToString("X4") + " " + bytes.Length + " " + packet.Encrypted.ToString() + Environment.NewLine + Utility.HexDump(bytes) + Environment.NewLine);
if (packet.Opcode == 0x6100)
{
this.locale = (Utility.SilkroadLocale)packet.ReadUInt8();
Program.main.localeSave = this.locale;
}
if (this.clientlessToClient)
{
#region Fake Client
#region 0x2001
if (packet.Opcode == 0x2001)
{
Packet response = new Packet(0x2001);
response.WriteAscii("GatewayServer");
response.WriteUInt8(0);
response.Lock();
this.gw_local_security.Send(response);
response = new Packet(0x2005, false, true);
response.WriteUInt8(0x01);
response.WriteUInt8(0x00);
response.WriteUInt8(0x01);
response.WriteUInt8(0xBA);
response.WriteUInt8(0x02);
response.WriteUInt8(0x05);
response.WriteUInt8(0x00);
response.WriteUInt8(0x00);
response.WriteUInt8(0x00);
response.WriteUInt8(0x02);
response.Lock();
gw_local_security.Send(response);
response = new Packet(0x6005, false, true);
response.WriteUInt8(0x03);
response.WriteUInt8(0x00);
response.WriteUInt8(0x02);
response.WriteUInt8(0x00);
response.WriteUInt8(0x02);
response.Lock();
gw_local_security.Send(response);
}
#endregion
#region 0x6100
if (packet.Opcode == 0x6100)
{
if (this.locale == Utility.SilkroadLocale.VSRO)
{
Packet response = new Packet(0xA100, false, true);
response.WriteUInt8(0x01);
response.Lock();
gw_local_security.Send(response);
}
else if (this.locale == Utility.SilkroadLocale.TRSRO)
{
Packet response = new Packet(0xA100, false, true);
response.WriteUInt8(0x01);
response.WriteUInt8(0x00);
response.Lock();
gw_local_security.Send(response);
}
}
#endregion
#region 0x6101
if (packet.Opcode == 0x6101)
{
if (this.locale == Utility.SilkroadLocale.VSRO)
{
Packet response = new Packet(0xA102);
response.WriteUInt8(0x01); //Sucess
response.WriteUInt32(uint.MaxValue); //SessionID
response.WriteAscii(Gateway.realIP); //AgentIP
response.WriteUInt16(Gateway.fakeAgentPort);
response.Lock();
gw_local_security.Send(response);
}
else if (this.locale == Utility.SilkroadLocale.TRSRO)
{
Packet response = new Packet(0xA10A);
response.WriteUInt8(0x01); //Sucess
response.WriteUInt32(uint.MaxValue); //SessionID
response.WriteAscii(Gateway.realIP); //AgentIP
response.WriteUInt16(Gateway.fakeAgentPort);
response.WriteUInt8(1);
response.Lock();
gw_local_security.Send(response);
}
}
#endregion
#region 0x6103
if (packet.Opcode == 0x6103)
{
if (this.locale == Utility.SilkroadLocale.VSRO)
{
Packet response = new Packet(0xA103);
response.WriteUInt8(0x01); //Sucess
response.Lock();
gw_local_security.Send(response);
}
else if (this.locale == Utility.SilkroadLocale.TRSRO)
{
Packet response = new Packet(0xA103);
response.WriteUInt8(0x01); //Sucess
response.WriteUInt8(0x03);
response.WriteUInt8(0x00);
response.Lock();
gw_local_security.Send(response);
}
}
#endregion
#region 0x7007
if (packet.Opcode == 0x7007)
{
byte type = packet.ReadUInt8();
if (type == 0x02)
{
Packet responseEndCS = new Packet(0xB001);
responseEndCS.WriteUInt8(0x01);
Packet responseInitLoad = new Packet(0x34A5);
gw_local_security.Send(responseEndCS);
gw_local_security.Send(responseInitLoad);
}
}
#endregion
#endregion
}
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000 || packet.Opcode == 0x2001)
{
if (!this.gw_remote_client.Connected && !this.clientlessToClient)
{
string ip = "127.0.0.1";
int port = Program.main.getFreeBotPort();
if (port != 0)
{
Program.main.portSave = port;
this.gw_remote_client.Connect(ip, port);
this.gw_remote_client.Blocking = false;
this.gw_remote_client.NoDelay = true;
Thread thread = new Thread(new ThreadStart(this.GatewayRemoteThread));
thread.Start();
}
else
{
Program.main.MainLog("Cannot find free Bot");
return;
}
}
}
else
{
this.gw_remote_security.Send(packet);
}
}
}
this.gw_local_send_buffers = this.gw_local_security.TransferOutgoing();
if (this.gw_local_send_buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> current in this.gw_local_send_buffers)
{
Packet packet = current.Value;
TransferBuffer key = current.Key;
while (key.Offset != key.Size)
{
this.gw_local_client.Blocking = true;
int num = this.gw_local_client.Send(key.Buffer, key.Offset, key.Size - key.Offset, SocketFlags.None);
this.gw_local_client.Blocking = false;
key.Offset += num;
}
byte[] bytes = packet.GetBytes();
}
}
Thread.Sleep(1);
}
}
catch (Exception ex)
{
Log.LogMsg("LocalThread error, disconnecting " + this.ip);
this.CleanClient();
}
}
private void GatewayRemoteThread()
{
try
{
while (this.remote)
{
this.gw_remote_recv_buffer.Offset = 0;
SocketError socketError;
this.gw_remote_recv_buffer.Size = this.gw_remote_client.Receive(this.gw_remote_recv_buffer.Buffer, 0, this.gw_remote_recv_buffer.Buffer.Length, SocketFlags.None, out socketError);
if (socketError != SocketError.Success)
{
if (socketError != SocketError.WouldBlock)
{
this.CleanClient();
break;
}
}
else
{
if (!this.gw_remote_client.Connected || this.gw_remote_recv_buffer.Size <= 0)
{
this.CleanClient();
break;
}
this.gw_remote_security.Recv(this.gw_remote_recv_buffer);
}
this.gw_remote_recv_packets = this.gw_remote_security.TransferIncoming();
if (this.gw_remote_recv_packets != null)
{
foreach (Packet packet in this.gw_remote_recv_packets)
{
byte[] bytes = packet.GetBytes();
//Log.LogMsg("GW [S->C] " + packet.Opcode.ToString("X4") + " " + bytes.Length + " " + packet.Encrypted.ToString() + Environment.NewLine + Utility.HexDump(bytes) + Environment.NewLine);
if (packet.Opcode != 0x5000 && packet.Opcode != 0x9000)
{
switch (locale)
{
case Utility.SilkroadLocale.VSRO:
if (packet.Opcode == 0xA102)
{
byte b = packet.ReadUInt8();
if (b == 1)
{
uint value = packet.ReadUInt32();
string text = packet.ReadAscii();
uint port = packet.ReadUInt16();
Log.LogMsg("Redirect Client!");
Packet packet2 = new Packet(0xA102, true);
packet2.WriteUInt8(b);
packet2.WriteUInt32(value);
packet2.WriteAscii(Gateway.realIP);
packet2.WriteUInt16(Gateway.fakeAgentPort);
this.gw_local_security.Send(packet2);
Thread.Sleep(2000);
continue;
}
}
break;
case Utility.SilkroadLocale.TRSRO:
if (packet.Opcode == 0xA10A)
{
byte b = packet.ReadUInt8();
if (b == 1)
{
uint value = packet.ReadUInt32();
string text = packet.ReadAscii();
uint port = packet.ReadUInt16();
byte rnd = packet.ReadUInt8();
Log.LogMsg("Redirect Client!");
Packet packet2 = new Packet(0xA10A, true);
packet2.WriteUInt8(b);
packet2.WriteUInt32(value);
packet2.WriteAscii(Gateway.realIP);
packet2.WriteUInt16(Gateway.fakeAgentPort);
packet2.WriteUInt8(rnd);
this.gw_local_security.Send(packet2);
Thread.Sleep(2000);
continue;
}
}
break;
}
this.gw_local_security.Send(packet);
}
}
}
this.gw_remote_send_buffers = this.gw_remote_security.TransferOutgoing();
if (this.gw_remote_send_buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> current in this.gw_remote_send_buffers)
{
Packet packet = current.Value;
TransferBuffer key = current.Key;
while (key.Offset != key.Size)
{
this.gw_remote_client.Blocking = true;
int num2 = this.gw_remote_client.Send(key.Buffer, key.Offset, key.Size - key.Offset, SocketFlags.None);
this.gw_remote_client.Blocking = false;
key.Offset += num2;
Thread.Sleep(1);
}
byte[] bytes = packet.GetBytes();
}
}
Thread.Sleep(1);
}
}
catch (Exception ex)
{
this.CleanClient();
}
}
public BufferedSampleProvider(WaveFormat format, int bufferSize)
{
_format = format;
_samples = new TransferBuffer <float>(bufferSize);
}
/// <summary>
/// Gets the underlying COM object for a given resource, as a specified interface. This method invokes
/// <see href="https://docs.microsoft.com/windows/win32/api/unknwn/nf-unknwn-iunknown-queryinterface(refiid_void)">IUnknown::QueryInterface</see>.
/// </summary>
/// <typeparam name="T">The type of items stored on the buffer.</typeparam>
/// <param name="buffer">The input <see cref="TransferBuffer{T}"/> instance in use.</param>
/// <param name="riid">A reference to the interface identifier (IID) of the resource interface being queried for.</param>
/// <param name="ppvObject">The address of a pointer to an interface with the IID specified in <paramref name="riid"/>.</param>
/// <exception cref="Win32Exception">Thrown if the <c>IUnknown::QueryInterface</c> call doesn't return <c>S_OK</c>.</exception>
public static void GetID3D12Resource <T>(TransferBuffer <T> buffer, Guid *riid, void **ppvObject)
where T : unmanaged
{
buffer.D3D12Resource->QueryInterface(riid, ppvObject).Assert();
}
static void Main(string[] args)
{
ModuleInjector.Config.LoadEverything();
Console.BackgroundColor = ConsoleColor.White;
Console.Clear();
Console.ForegroundColor = ConsoleColor.Black;
Console.Title = "Packet Analyzer by [ROOT].";
try
{
String local_host;
Int32 local_port;
String remote_host;
Int32 remote_port;
local_host = FilterMain.cRemoteIP;
local_port = FilterMain.FindThisPort;
remote_host = FilterMain.cRemoteIP;
remote_port = FilterMain.ReplaceByThisPort;
Context local_context = new Context();
local_context.Security.GenerateSecurity(true, false, true);
Context remote_context = new Context();
remote_context.RelaySecurity = local_context.Security;
local_context.RelaySecurity = remote_context.Security;
List <Context> contexts = new List <Context>();
contexts.Add(local_context);
contexts.Add(remote_context);
using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
server.Bind(new IPEndPoint(IPAddress.Parse(local_host), local_port));
server.Listen(1);
local_context.Socket = server.Accept();
}
using (local_context.Socket)
{
using (remote_context.Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
remote_context.Socket.Connect(remote_host, remote_port);
while (true)
{
if (Console.KeyAvailable == true) // Application event processing
{
ConsoleKeyInfo key = Console.ReadKey(true);
if (key.Key == ConsoleKey.Escape)
{
break;
}
}
foreach (Context context in contexts) // Network input event processing
{
if (context.Socket.Poll(0, SelectMode.SelectRead))
{
int count = context.Socket.Receive(context.Buffer.Buffer);
if (count == 0)
{
throw new Exception("The remote connection has been lost.");
}
context.Security.Recv(context.Buffer.Buffer, 0, count);
}
}
foreach (Context context in contexts) // Logic event processing
{
List <Packet> packets = context.Security.TransferIncoming();
if (packets != null)
{
foreach (Packet packet in packets)
{
if (packet.Opcode == 0x5000 || packet.Opcode == 0x9000) // ignore always
{
}
else if (packet.Opcode == 0x2001)
{
string ModuleName = packet.ReadAscii();
if (context == remote_context) // ignore local to proxy only
{
Console.WriteLine("Remote Context: Module: " + ModuleName);
context.RelaySecurity.Send(packet); // proxy to remote is handled by API
}
else if (context == local_context) // ignore local to proxy only
{
Console.WriteLine("Local Context: Module: " + ModuleName);
context.RelaySecurity.Send(packet); // proxy to remote is handled by API
}
}
else if (packet.Opcode == 0x7025)
{
int chat_type = packet.ReadUInt8();
if (chat_type == 3)
{
uint id = packet.ReadUInt8();
string message = packet.ReadAscii();
if (message.ToLower().Contains("envia") || message.ToLower().Contains("send"))
{
int JID = Convert.ToInt32(message.Replace("envia ", "").Replace("send ", ""));
/* 01 A9 61 2A 02 FA FF 05 07 03 00 00 00 */
Console.Title = "Envia recibido!";
Packet move = new Packet(0x7021);
move.WriteUInt8(0x01);
move.WriteUInt8(0xA9);
move.WriteUInt8(0x61);
move.WriteUInt8(0x2A);
move.WriteUInt8(0x02);
move.WriteUInt8(0xFA);
move.WriteUInt8(0xFF);
move.WriteUInt8(0x05);
move.WriteUInt8(0x07);
move.WriteUInt8(JID);
move.WriteUInt8(0x00);
move.WriteUInt8(0x00);
move.WriteUInt8(0x00);
context.RelaySecurity.Send(move);
}
}
context.RelaySecurity.Send(packet);
}
else
{
context.RelaySecurity.Send(packet);
}
}
}
}
foreach (Context context in contexts) // Network output event processing
{
if (context.Socket.Poll(0, SelectMode.SelectWrite))
{
List <KeyValuePair <TransferBuffer, Packet> > buffers = context.Security.TransferOutgoing();
if (buffers != null)
{
foreach (KeyValuePair <TransferBuffer, Packet> kvp in buffers)
{
TransferBuffer buffer = kvp.Key;
Packet packet = kvp.Value;
byte[] packet_bytes = packet.GetBytes();
Console.WriteLine("[{0}][{1:X4}][{2} bytes]{3}{4}{6}{5}{6}", context == local_context ? "GS->AS" : "AS->GS", packet.Opcode, packet_bytes.Length, packet.Encrypted ? "[Encrypted]" : "", packet.Massive ? "[Massive]" : "", Utility.HexDump(packet_bytes), Environment.NewLine);
while (true)
{
int count = context.Socket.Send(buffer.Buffer, buffer.Offset, buffer.Size, SocketFlags.None);
buffer.Offset += count;
if (buffer.Offset == buffer.Size)
{
break;
}
Thread.Sleep(1);
}
}
}
}
}
Thread.Sleep(1); // Cycle complete, prevent 100% CPU usage
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
