public static string StartCheck(string read)
{
ReadObj message = JsonConvert.DeserializeObject <ReadObj>(Funtion.RemoveColorCodes(read));
if (message.data == DataType.start)
{
return(message.message);
}
return(null);
}
private void AcceptClient(IAsyncResult ar)
{
Socket client = null;
bool allow;
try
{
client = server.EndAccept(ar);
}
catch (Exception)
{
return;
}
IPEndPoint client_ep = (IPEndPoint)client.RemoteEndPoint;
string remoteAddress = client_ep.Address.ToString();
string remotePort = client_ep.Port.ToString();
if (!autoAllow)
{
Console.WriteLine("\n[IN] Connection " + remoteAddress + ":" + remotePort + "\nDo you want to allow this connection?");
string answer = Console.ReadLine();
allow = answer == "yes" ? true : false;
}
else
{
allow = true;
}
if (allow)
{
//Console.WriteLine("Step 1");
clientList.Add(client);
ReadObj obj = new ReadObj
{
buffer = new byte[1024],
s = client
};
client.BeginReceive(obj.buffer, 0, obj.buffer.Length, SocketFlags.None, new AsyncCallback(ReadPackets), obj);
}
else
{
KillSocket(client);
Console.WriteLine("[REJECT] " + remoteAddress + ":" + remotePort);
}
if (!stopping)
{
server.BeginAccept(new AsyncCallback(AcceptClient), null);
}
}
public void InitAsyncRead()
{
ReadObj r = new ReadObj
{
full = "",
r = null,
requestHandled = false
};
_ssl.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(ReadFromStream), r);
}
private void AcceptClient(IAsyncResult ar)
{
Socket client = null;
try
{
client = server.EndAccept(ar);
}
catch (Exception)
{
return;
}
IPEndPoint client_ep = (IPEndPoint)client.RemoteEndPoint;
string remoteAddress = client_ep.Address.ToString();
string remotePort = client_ep.Port.ToString();
//TODO: Implement block command -> keep the server and existing connections alive, but drop new connections
bool allow;
if (!autoAllow)
{
allow = console.ChoicePrompt("\n[IN] Connection " + remoteAddress + ":" + remotePort + "\nDo you want to allow connection");
}
else
{
allow = true;
}
if (allow)
{
clientList.Add(client);
ReadObj obj = new ReadObj
{
buffer = new byte[1024],
s = client
};
client.BeginReceive(obj.buffer, 0, obj.buffer.Length, SocketFlags.None, new AsyncCallback(ReadPackets), obj);
}
else
{
KillSocket(client, !stopping);
ctx.LogMod.Log("[REJECT] " + remoteAddress + ":" + remotePort, VLogger.LogLevel.information);
}
if (!stopping)
{
server.BeginAccept(new AsyncCallback(AcceptClient), null);
}
}
internal static Entity CreateEntityFromPointer(IntPtr entityPointer)
{
string getClassId = ReadObj.ReadClassFromPointer(entityPointer);
if (getClassId.Contains("DOTA_Ability") || getClassId.Contains("BaseAbility"))
{
return(new Ability(entityPointer));
}
if (getClassId.Contains("DOTA_Unit_Hero"))
{
return(new Hero(entityPointer));
}
if (getClassId.Contains("DOTAPlayer"))
{
return(new Player(entityPointer));
}
if (getClassId.Contains("DOTA_Item"))
{
return(new Item(entityPointer));
}
if (getClassId.Contains("BaseNPC_Creep_Lane"))
{
return(new Creep(entityPointer));
}
if (getClassId.Contains("BaseNPC_Creep_Neutral"))
{
return(new Neutral(entityPointer));
}
if (getClassId.Contains("BaseNPC_Shop"))
{
return(new Shop(entityPointer));
}
if (getClassId.Contains("BaseNPC_Tower"))
{
return(new Tower(entityPointer));
}
if (getClassId.Contains("DOTA_Unit_Courier"))
{
return(new Courier(entityPointer));
}
if (getClassId.Contains("BaseNPC_Building"))
{
return(new Building(entityPointer));
}
return(new Entity(entityPointer));
}
private void ReadPackets(IAsyncResult ar)
{
ReadObj obj = (ReadObj)ar.AsyncState;
Socket client = obj.s;
byte[] buffer = obj.buffer;
int read = -1;
try
{
read = client.EndReceive(ar);
}
catch (Exception)
{
KillSocket(client, !stopping);
ctx.LogMod.Log("[DISCONNECT] Client Disconnected from server", VLogger.LogLevel.information);
return;
}
if (read == 0)
{
try { if (client.Connected)
{
client.BeginReceive(obj.buffer, 0, obj.buffer.Length, SocketFlags.None, new AsyncCallback(ReadPackets), obj);
}
}
catch (Exception e)
{
KillSocket(client, !stopping);
Console.WriteLine("Client aborted session!" + Environment.NewLine + e.Message);
}
return;
}
string text = Encoding.ASCII.GetString(buffer, 0, read);
Request r;
bool sslHandlerStarted = false;
if (obj.request != null)
{
if (obj.request.notEnded)
{
string des = obj.request.full;
des += text;
r = new Request(des);
}
else
{
r = new Request(text);
}
}
else
{
r = new Request(text);
}
if (!r.notEnded && !r.bogus)
{
ctx.LogMod.Log("<target> [HTTP]", VLogger.LogLevel.request, r);
Tunnel t = new Tunnel(Tunnel.Mode.HTTP, httpMode, httpsMode, ctx, client, console);
t.CreateMinimalTunnel(r);
if (t.sslRead && httpMode == Mode.MITM) //Handle MITM SSL Connections
{
string host = t.GetHost();
NetworkStream clientNS = new NetworkStream(client);
VSslHandler vsh = new VSslHandler(ctx, console);
VSslHandler.Error errCode = vsh.InitSslStream(clientNS, host);
if (errCode != VSslHandler.Error.Success)
{
ctx.LogMod.Log("Init SSL Stream failed\r\nError Code: " + errCode.ToString(), VLogger.LogLevel.error);
}
else
{
sslHandlerStarted = true;
vsh.InitAsyncRead();
console.Debug("SSL Tunnel MITM Started");
return;
}
}
else if (t.sslRead && httpsMode == Mode.forward) //Handle HTTPS normal
{
t.InitHTTPS(client);
return;
}
if (httpMode == Mode.MITM) //Handle HTTP MITM
{
Request httpSend = new Request(t.FormatRequest(r));
Tunnel.Send("", Tunnel.Mode.HTTP, ctx, httpSend, new NetworkStream(client));
}
else if (httpMode == Mode.forward) //Handle HTTP normal
{
t.SendHTTP(r, client);
return;
}
}
else if (r.notEnded)
{
obj.request = r;
}
Array.Clear(buffer, 0, buffer.Length);
try { if (client.Connected && !sslHandlerStarted)
{
client.BeginReceive(obj.buffer, 0, obj.buffer.Length, SocketFlags.None, new AsyncCallback(ReadPackets), obj);
}
}
catch (Exception e)
{
KillSocket(client, !stopping);
Console.WriteLine("Client aborted session!" + Environment.NewLine + e.Message);
}
}
private void ReadPackets(IAsyncResult ar)
{
ReadObj obj = (ReadObj)ar.AsyncState;
Socket client = obj.s;
byte[] buffer = obj.buffer;
int read = -1;
try
{
//Console.WriteLine("Step 2");
read = client.EndReceive(ar);
}
catch (Exception)
{
KillSocket(client, !stopping);
Console.WriteLine("[DISCONNECT] Client disconnected from server");
return;
}
if (read == 0)
{
try
{
if (client.Connected)
{
client.BeginReceive(obj.buffer, 0, obj.buffer.Length, SocketFlags.None, new AsyncCallback(ReadPackets), obj);
}
}
catch (Exception e)
{
KillSocket(client, !stopping);
Console.WriteLine("Client aborted session!" + Environment.NewLine + e.Message);
}
return;
}
string requestHeader = Encoding.ASCII.GetString(buffer, 0, read);
//Console.WriteLine(requestHeader);
#region Check blacklist
foreach (var key in ConfigurationManager.AppSettings.AllKeys)
{
if (requestHeader.Contains(ConfigurationManager.AppSettings[key].ToString()))
{
Response403Forbidden(client);
return;
}
}
#endregion
Request req = new Request(requestHeader);
//bool sslHandlerStarted = false;
//Console.WriteLine("Step 3");
Tunnel tunnel = new Tunnel(Tunnel.Mode.HTTPs, httpMode, httpsMode, ref client);
tunnel.CreateMinimalTunnel(req);
if (tunnel.sslRead && httpsMode == Mode.Forward) //Handle HTTPS normal
{
//Console.WriteLine("Step 4");
tunnel.SendHTTPS(client);
return;
}
else if (httpMode == Mode.Forward) //Handle HTTP normal
{
tunnel.SendHTTP(req, client);
return;
}
Array.Clear(buffer, 0, buffer.Length);
//try {
// if (client.Connected && !sslHandlerStarted)
// client.BeginReceive(obj.buffer, 0, obj.buffer.Length, SocketFlags.None, new AsyncCallback(ReadPackets), obj);
//}
//catch (Exception e)
//{
// KillSocket(client, !stopping);
// Console.WriteLine("Client aborted session!" + Environment.NewLine + e.Message);
//}
}
public string Name() => ReadObj.ReadNameFromPointer(EntityPointer);
public string ClassIdName() => ReadObj.ReadClassFromPointer(EntityPointer);
public ClassId ClassId() => (ClassId)Enum.Parse(typeof(ClassId), ReadObj.ReadClassFromPointer(EntityPointer), true);
private void ReadFromStream(IAsyncResult ar)
{
ReadObj ro = (ReadObj)ar.AsyncState;
Request r = ro.r;
int bytesRead = 0;
try { bytesRead = _ssl.EndRead(ar); }
catch (Exception) { return; }
byte[] read = new byte[bytesRead];
Array.Copy(buffer, read, bytesRead);
string text = Encoding.ASCII.GetString(read);
if (bytesRead > 0)
{
if (r == null)
{
r = new Request(text, true);
}
if (r.notEnded)
{
if (ro.full == "")
{
ro.full = text;
}
else
{
ro.full += text;
r = new Request(ro.full, true);
}
}
if (!r.notEnded && !r.bogus)
{
if (ctx.mitmHttp.started)
{
ctx.mitmHttp.DumpRequest(r);
}
string requestString = r.Deserialize();
Tunnel.Send(requestString, Tunnel.Mode.HTTPs, ctx, r, null, this);
ro.full = "";
ro.requestHandled = true;
}
}
Array.Clear(buffer, 0, buffer.Length);
if (!ro.requestHandled)
{
ro.r = r;
}
else
{
ro.r = null;
ro.requestHandled = false;
}
try { _ssl.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(ReadFromStream), ro); }
catch (Exception ex)
{
//ctx.LogMod.Log("Ssl stream error MITM\r\n" + ex.Message, VLogger.LogLevel.error);
Console.WriteLine("St: " + ex.StackTrace);
}
}
public void MessageDo(string server, string read)
{
ReadObj message = JsonConvert.DeserializeObject <ReadObj>(Funtion.RemoveColorCodes(read));
if (string.IsNullOrWhiteSpace(message.data))
{
return;
}
switch (message.data)
{
case DataType.data:
if (string.IsNullOrWhiteSpace(message.message) == true ||
string.IsNullOrWhiteSpace(message.player) == true)
{
return;
}
if (Main.PlayerConfig.MuteList.Contains(message.player.ToLower()) == true)
{
return;
}
if (message.group == DataType.group)
{
if (Main.MainConfig.Setting.SendNickGroup == true)
{
PlayerObj player = Main.GetPlayer(message.player);
if (player != null && string.IsNullOrWhiteSpace(player.Nick) == false)
{
message.message = Funtion.ReplaceFirst(message.message, message.player, player.Nick);
}
}
foreach (var item in Main.GroupConfig.Groups)
{
if (item.Value.EnableSay)
{
Main.SendGroup.AddSend(new()
{
Group = item.Key,
Message = message.message
});
}
}
}
else
{
long.TryParse(message.group, out long group);
if (Main.GroupConfig.Groups.ContainsKey(group))
{
Main.SendGroup.AddSend(new()
{
Group = group,
Message = message.message
});
}
}
break;
case DataType.config:
IMinecraft_QQ.ServerConfigCall?.Invoke(server, message.message);
break;
default:
break;
}
}
