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