private static Tunnel CheckVersion(string firstMsg, Socket socket2Client) { Tunnel result = null; string[] args = firstMsg.Split(' '); if (args.Length >= 3) { string reply = ""; bool valid = args[0] == "eagle_tunnel"; reply = valid ? "valid" : "invalid"; bool valid1 = args[1] == "1.0"; valid &= valid1; reply += valid1 ? " valid" : " invalid"; valid1 = args[2] == "simple"; valid &= valid1; reply += valid1 ? " valid" : " invalid"; if (valid) { byte[] buffer = System.Text.Encoding.ASCII.GetBytes(reply); int written = socket2Client.Send(buffer); if (written > 0) { result = new Tunnel(socket2Client); result.EncryptL = true; } } } return(result); }
public static bool Handle(ByteBuffer request, Tunnel tunnel) { bool result = false; if (request != null && tunnel != null) { int version = request[0]; // check if is socks version 5 if (version == '\u0005') { string reply = "\u0005\u0000"; result = tunnel.WriteL(reply); if (result) { ByteBuffer buffer = new ByteBuffer(); int read = tunnel.ReadL(buffer); if (read >= 2) { SOCKS5_CMDType cmdType = (SOCKS5_CMDType)buffer[1]; switch (cmdType) { case SOCKS5_CMDType.Connect: result = HandleTCPReq(buffer, tunnel); break; } } } } } return(result); }
private static void DNSReqSender(Tunnel tunnel, EagleTunnelArgs e) { if (tunnel != null && e != null) { e.IP = null; if (e.Domain != null) { if (IPAddress.TryParse(e.Domain, out IPAddress ip0)) { ; // e.Domain is IP but not domain e.IP = ip0; } else { string req = EagleTunnelHandler.EagleTunnelRequestType.DNS.ToString(); req += " " + e.Domain; bool done = tunnel.WriteR(req); if (done) { string reply = tunnel.ReadStringR(); if (!string.IsNullOrEmpty(reply) && reply != "nok") { if (IPAddress.TryParse(reply, out IPAddress ip1)) { e.IP = ip1; } } } } } } }
private static bool CheckAuthen(Tunnel tunnel) { bool result = false; if (!Conf.allConf.ContainsKey("user-conf")) { result = true; } else { byte[] buffer = new byte[100]; string req = tunnel.ReadStringL(); if (!string.IsNullOrEmpty(req)) { if (EagleTunnelUser.TryParse(req, out EagleTunnelUser user)) { if (Conf.Users.ContainsKey(user.ID)) { result = Conf.Users[user.ID].CheckAuthen(user.Password); } } } string reply = result ? "valid" : "invalid"; result &= tunnel.WriteL(reply); } return(result); }
private static Tunnel CheckVersion(Socket socket2Server) { Tunnel result = null; if (socket2Server != null) { string req = "eagle_tunnel 1.0 simple"; byte[] buffer = Encoding.ASCII.GetBytes(req); int written; try { written = socket2Server.Send(buffer); } catch { written = 0; } if (written > 0) { buffer = new byte[100]; int read; try { read = socket2Server.Receive(buffer); } catch { read = 0; } if (read > 0) { string reply = Encoding.UTF8.GetString(buffer, 0, read); if (reply == "valid valid valid") { result = new Tunnel(null, socket2Server); result.EncryptR = true; } } } } return(result); }
private static EagleTunnelUser CheckAuthen(Tunnel tunnel) { EagleTunnelUser result = null; if (Conf.allConf.ContainsKey("user-check") && Conf.allConf["user-check"][0] == "on") { string req = tunnel.ReadStringL(); if (!string.IsNullOrEmpty(req)) { if (EagleTunnelUser.TryParse(req, out EagleTunnelUser user, false)) { result = EagleTunnelUser.Check(user.ID, user.Password); } } string reply = result != null ? "valid" : "invalid"; result = tunnel.WriteL(reply) ? result : null; } else { if (EagleTunnelUser.users.ContainsKey("anonymous")) { result = EagleTunnelUser.users["anonymous"]; } } return(result); }
private static bool CheckVersion(string firstMsg, Tunnel tunnel) { bool result; string[] args = firstMsg.Split(' '); if (args.Length >= 3) { string reply = ""; result = args[0] == "eagle_tunnel"; reply = result ? "valid" : "invalid"; bool valid1 = args[1] == Server.ProtocolVersion; result &= valid1; reply += valid1 ? " valid" : " invalid"; valid1 = args[2] == "simple"; result &= valid1; reply += valid1 ? " valid" : " invalid"; if (result) { result = tunnel.WriteL(reply); if (result) { tunnel.EncryptL = true; } } } else { result = false; } return(result); }
private static bool CheckUser(Tunnel tunnel) { bool result = false; if (tunnel != null) { if (Conf.LocalUser != null) { bool done = tunnel.WriteR(Conf.LocalUser.ToString()); if (done) { string reply = tunnel.ReadStringR(); if (!string.IsNullOrEmpty(reply)) { result = reply == "valid"; } } } else { result = true; } } return(result); }
private static bool HandleTCPReq(ByteBuffer request, Tunnel tunnel) { bool result = false; if (request != null && tunnel != null) { IPAddress ip = GetIP(request); int port = GetPort(request); if (ip != null && port != 0) { IPEndPoint reqIPEP = new IPEndPoint(ip, port); string reply; EagleTunnelArgs e = new EagleTunnelArgs(); e.EndPoint = reqIPEP; e.tunnel = tunnel; if (EagleTunnelSender.Handle( EagleTunnelHandler.EagleTunnelRequestType.TCP, e)) { if (Conf.LocalUser != null) { Conf.LocalUser.AddTunnel(tunnel); } reply = "\u0005\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000"; } else { reply = "\u0005\u0001\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000"; } result = tunnel.WriteL(reply); } } return(result); }
public void AddTunnel(Tunnel tunnel2Add) { if (Conf.allConf.ContainsKey("speed-check")) { if (Conf.allConf["speed-check"][0] == "on") { tunnel2Add.IsWaiting = IsWaiting; tunnels.Enqueue(tunnel2Add); } } }
public static Tunnel Handle(byte[] firstMsg, Socket socket2Client) { Tunnel result = null; if (firstMsg != null && socket2Client != null) { Tunnel tunnel = null; string firstMsg_Str = Encoding.UTF8.GetString(firstMsg); RequestType reqType = GetType(firstMsg); switch (reqType) { case RequestType.Eagle_Tunnel: if (Conf.EnableEagleTunnel) { tunnel = EagleTunnelHandler.Handle( firstMsg_Str, socket2Client); } break; case RequestType.HTTP_Proxy: if (Conf.EnableHTTP) { tunnel = HTTPHandler.Handle( firstMsg_Str, socket2Client); } break; case RequestType.SOCKS5: if (Conf.EnableSOCKS) { tunnel = SocksHandler.Handle( firstMsg, socket2Client); } break; } if (tunnel != null) { result = tunnel; } else { if (socket2Client.Connected) { try { socket2Client.Shutdown(SocketShutdown.Both); Thread.Sleep(100); socket2Client.Close(); } catch {; } } } } return(result); }
private static void HandleDNSReq(string msg, Tunnel tunnel) { if (!string.IsNullOrEmpty(msg) && tunnel != null) { string[] args = msg.Split(' '); if (args.Length >= 2) { string domain = args[1]; string ip = ResolvDNS(domain); tunnel.WriteL(ip); } } }
private static void HandleClient(Socket socket2Client) { lock (clients) { while (clients.Count > Conf.maxClientsCount) { Tunnel tunnel2Close = clients.Dequeue(); tunnel2Close.Close(); } } Thread threadHandleClient = new Thread(_handleClient); threadHandleClient.IsBackground = true; threadHandleClient.Start(socket2Client); }
private static void handleClient(Socket socket2Client, int ipepIndex) { Tunnel tunnel2Add = new Tunnel(socket2Client, null, Conf.encryptionKey); bool result = RequestHandler.Handle(tunnel2Add); if (result) { tunnel2Add.Flow(); } else { tunnel2Add.Close(); } reqGotNumbers.Down(); }
private static bool CheckVersion(Tunnel tunnel) { bool isValid = false; string req = "eagle_tunnel " + Server.ProtocolVersion + " simple"; if (tunnel.WriteR(req, Encoding.ASCII)) { string reply = tunnel.ReadStringR(); if (!string.IsNullOrEmpty(reply)) { isValid = reply == "valid valid valid"; } } return(isValid); }
private static void HandleDNSReq(string msg, Tunnel tunnel) { if (!string.IsNullOrEmpty(msg) && tunnel != null) { string[] args = msg.Split(' '); if (args.Length >= 2) { string domain = args[1]; IPAddress ip; if (dnsCaches.ContainsKey(domain)) { if (!dnsCaches[domain].IsDead) { ip = dnsCaches[domain].IP; } else { ip = ResolvDNS(domain); if (ip != null) { dnsCaches[domain].IP = ip; } } } else { ip = ResolvDNS(domain); if (ip != null) { DnsCache cache = new DnsCache(domain, ip, Conf.DnsCacheTtl); dnsCaches.TryAdd(cache.Domain, cache); } } string reply; if (ip == null) { reply = "nok"; } else { reply = ip.ToString(); } tunnel.WriteL(reply); } } }
private static bool CreateTunnel(out Tunnel tunnel) { bool succeed = false; Tunnel result = new Tunnel(null, null, Conf.encryptionKey); succeed = Connect2Relayer(result); if (succeed) { tunnel = result; } else { result.Close(); tunnel = null; } return(succeed); }
public static bool Handle(Tunnel tunnel) { bool result = false; if (tunnel == null) { result = false; } else { ByteBuffer firstMsg = new ByteBuffer(); int read = tunnel.ReadL(firstMsg); if (read > 0) { string firstMsg_Str = firstMsg.ToString(); RequestType reqType = GetType(firstMsg); switch (reqType) { case RequestType.Eagle_Tunnel: if (Conf.EnableEagleTunnel) { result = EagleTunnelHandler.Handle( firstMsg_Str, tunnel); } break; case RequestType.HTTP_Proxy: if (Conf.EnableHTTP) { result = HTTPHandler.Handle( firstMsg_Str, tunnel); } break; case RequestType.SOCKS5: if (Conf.EnableSOCKS) { result = SocksHandler.Handle( firstMsg, tunnel); } break; } } } return(result); }
public static bool Handle(string firstMsg, Tunnel tunnel) { bool result = false; if (!string.IsNullOrEmpty(firstMsg) && tunnel != null) { bool isVersionRight = CheckVersion(firstMsg, tunnel); if (isVersionRight) { EagleTunnelUser user = CheckAuthen(tunnel); if (user != null) { string req = tunnel.ReadStringL(); if (!string.IsNullOrEmpty(req)) { EagleTunnelRequestType type = GetType(req); switch (type) { case EagleTunnelRequestType.DNS: HandleDNSReq(req, tunnel); break; case EagleTunnelRequestType.TCP: result = TCPReqHandle(req, tunnel); if (result) { user.AddTunnel(tunnel); } break; case EagleTunnelRequestType.LOCATION: HandleLOCATIONReq(req, tunnel); break; case EagleTunnelRequestType.Unknown: default: break; } } } } } return(result); }
private static Tunnel HandleTCPReq(byte[] request, Socket socket2Client) { Tunnel result = null; if (request != null && socket2Client != null) { IPAddress ip = GetIP(request); int port = GetPort(request); if (ip != null && port != 0) { IPEndPoint reqIPEP = new IPEndPoint(ip, port); string reply; EagleTunnelArgs e = new EagleTunnelArgs(); e.EndPoint = reqIPEP; result = EagleTunnelSender.Handle( EagleTunnelHandler.EagleTunnelRequestType.TCP, e); if (result != null) { reply = "\u0005\u0000\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000"; } else { reply = "\u0005\u0001\u0000\u0001\u0000\u0000\u0000\u0000\u0000\u0000"; } byte[] buffer = Encoding.ASCII.GetBytes(reply); int written; try { written = socket2Client.Send(buffer); } catch { written = 0; } if (result != null) { if (written > 0) { result.SocketL = socket2Client; } else { result.Close(); result = null; } } } } return(result); }
private static void HandleLOCATIONReq(string req, Tunnel tunnel) { string[] reqs = req.Split(' '); if (reqs.Length >= 2) { string ip2Resolv = reqs[1]; string result; if (insideCache.ContainsKey(ip2Resolv)) { result = insideCache[ip2Resolv].ToString(); } else { ips2Resolv.Enqueue(ip2Resolv); result = "not found"; } tunnel.WriteL(result); } }
public static Tunnel Handle( string firstMsg, System.Net.Sockets.Socket socket2Client) { Tunnel result = null; if (firstMsg != null && socket2Client != null) { if (HTTPReqArgs.TryParse(firstMsg, out HTTPReqArgs e0)) { IPEndPoint reqEP = HTTPReqArgs.GetIPEndPoint(e0); EagleTunnelArgs e1 = new EagleTunnelArgs(); e1.EndPoint = reqEP; Tunnel tunnel = EagleTunnelSender.Handle( EagleTunnelHandler.EagleTunnelRequestType.TCP, e1); if (tunnel != null) { tunnel.SocketL = socket2Client; bool done; if (e0.HTTP_Request_Type == HTTPRequestType.CONNECT) { // HTTPS: reply web client; string re443 = "HTTP/1.1 200 Connection Established\r\n\r\n"; done = tunnel.WriteL(re443); } else { // HTTP: relay new request to web server string newReq = HTTPReqArgs.CreateNewRequest(firstMsg); done = tunnel.WriteR(newReq); } if (done) { result = tunnel; } else { tunnel.Close(); } } } } return(result); }
public static Tunnel Handle(EagleTunnelHandler.EagleTunnelRequestType type, EagleTunnelArgs e) { Tunnel result = null; if (type != EagleTunnelHandler.EagleTunnelRequestType.Unknown && e != null) { IPEndPoint ipeOfServer = Conf.GetRemoteIPEndPoint(); Socket socket2Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { socket2Server.Connect(ipeOfServer); } catch { socket2Server = null; } Tunnel tunnel = CheckVersion(socket2Server); if (tunnel != null) { bool done = CheckUser(tunnel); if (done) { switch (type) { case EagleTunnelHandler.EagleTunnelRequestType.DNS: DNSReqSender(tunnel, e); done = false; // no need to continue; break; case EagleTunnelHandler.EagleTunnelRequestType.TCP: done = TCPReqSender(tunnel, e); break; } } if (done) { result = tunnel; } else { tunnel.Close(); } } } return(result); }
public static Tunnel Handle(string firstMsg, Socket socket2Client) { Tunnel result = null; if (!string.IsNullOrEmpty(firstMsg) && socket2Client != null) { Tunnel tunnel = CheckVersion(firstMsg, socket2Client); if (tunnel != null) { if (CheckAuthen(tunnel)) { string req = tunnel.ReadStringL(); if (!string.IsNullOrEmpty(req)) { EagleTunnelRequestType type = GetType(req); bool done = false; switch (type) { case EagleTunnelRequestType.DNS: HandleDNSReq(req, tunnel); // no need to continue; break; case EagleTunnelRequestType.TCP: done = TCPReqHandle(req, tunnel); break; } if (done) { result = tunnel; } else { tunnel.Close(); } } } } } return(result); }
private static bool TCPReqSender(Tunnel tunnel, EagleTunnelArgs e) { bool result = false; if (tunnel != null && e != null) { if (e.EndPoint != null) { string req = EagleTunnelHandler.EagleTunnelRequestType.TCP.ToString(); req += ' ' + e.EndPoint.Address.ToString(); req += ' ' + e.EndPoint.Port.ToString(); bool done = tunnel.WriteR(req); if (done) { string reply = tunnel.ReadStringR(); result = reply == "ok"; } } } return(result); }
private static bool ConnectByProxy(EagleTunnelArgs e) { bool succeed = false; if (e.tunnel != null) { Tunnel tunnel = e.tunnel; if (Connect2Relayer(tunnel)) { string req = EagleTunnelHandler.EagleTunnelRequestType.TCP.ToString(); req += ' ' + e.EndPoint.Address.ToString(); req += ' ' + e.EndPoint.Port.ToString(); bool done = tunnel.WriteR(req); if (done) { string reply = tunnel.ReadStringR(); succeed = reply == "ok"; } } } return(succeed); }
private static bool TCPReqHandle(string msg, Tunnel tunnel) { bool result = false; if (msg != null && tunnel != null) { string[] args = msg.Split(' '); if (args.Length >= 3) { string ip = args[1]; string _port = args[2]; if (int.TryParse(_port, out int port)) { if (IPAddress.TryParse(ip, out IPAddress ipa)) { IPEndPoint ipeReq = new IPEndPoint(ipa, port); Socket socket2Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { socket2Server.Connect(ipeReq); result = true; } catch {; } if (result) { tunnel.SocketR = socket2Server; result = tunnel.WriteL("ok"); } else { tunnel.WriteL("nok"); } } } } } return(result); }
public static Tunnel Handle(byte[] request, Socket socket2Client) { Tunnel result = null; if (request != null && socket2Client != null) { int version = request[0]; // check if is socks version 5 if (version == '\u0005') { string reply = "\u0005\u0000"; byte[] buffer = Encoding.ASCII.GetBytes(reply); int written; try { written = socket2Client.Send(buffer); } catch { written = 0; } if (written > 0) { buffer = new byte[100]; int read; try { read = socket2Client.Receive(buffer); } catch { read = 0; } if (read > 0) { SOCKS5_CMDType cmdType = (SOCKS5_CMDType)buffer[1]; switch (cmdType) { case SOCKS5_CMDType.Connect: result = HandleTCPReq(buffer, socket2Client); break; } } } } } return(result); }
public static bool Connect2Relayer(Tunnel tunnel) { bool result = false; if (tunnel != null) { Socket socket2Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); IPEndPoint ipeOfServer = Conf.GetRemoteIPEndPoint(); try { socket2Server.Connect(ipeOfServer); } catch { socket2Server = null; } tunnel.SocketR = socket2Server; tunnel.EncryptR = false; if (CheckVersion(tunnel)) { tunnel.EncryptR = true; result = CheckUser(tunnel); } } return(result); }
private static void _handleClient(object socket2ClientObj) { Socket socket2Client = socket2ClientObj as Socket; byte[] buffer = new byte[1024]; int read; try { read = socket2Client.Receive(buffer); } catch { read = 0; } if (read > 0) { byte[] req = new byte[read]; Array.Copy(buffer, req, read); Tunnel tunnel = RequestHandler.Handle(req, socket2Client); if (tunnel != null) { tunnel.Flow(); lock (clients) { clients.Enqueue(tunnel); } } } }