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; } }