public WorldServer()
{
Config = new WorldServerConfig("Resources/Config/World.ini");
WorldDatabase = new WorldDatabase(Config);
if (WorldDatabase.Connection.CheckConnection())
{
Console.WriteLine("Connecting to cluster server...");
int clusterPort = (int)Config.GetSetting("ClusterPort");
int worldStartPort = (int)Config.GetSetting("WorldStartPort");
Console.WriteLine("Searching open port for cluster server communication...");
while (PortChecker.IsPortAvailable(worldStartPort))
{
Console.WriteLine("Port {0} not available, let's try another port", worldStartPort.ToString());
worldStartPort += 1;
}
ClusterConnector = new ClusterConnector(clusterPort.ToString(), worldStartPort.ToString());
ClusterConnector.StartListening();
// Let's wait a bit to let the subscriber and publisher socket to connect
Thread.Sleep(1500);
RegisterChannelRequest request = new RegisterChannelRequest((string)Config.GetSetting("ClusterAuthorizationPassword"), (string)Config.GetSetting("Address"), worldStartPort.ToString(), (string)Config.GetSetting("ChannelName"), 50, ClusterConnector.PublisherSocket);
ClusterConnector.OnRegisterChannelSuccesful += new ClusterConnector.RequestSuccesfulHandler(OnRegisterChannelSuccesful);
}
}
public void CheckPort_ShouldThrowExceptionBecauseHostNull()
{
PortChecker checker = new PortChecker();
Port portToCheck = new Port();
Assert.Throws <ArgumentNullException>("_host", () => checker.CheckPort(portToCheck));
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
IPortForwarder portForwarder = new PortForwarder();
IPortChecker portChecker = new PortChecker();
Application.Run(new FrmMain(portForwarder, portChecker));
}
public void CheckPort_ValidGoogleTcpPortCheck(string host, ushort port, PortState expect)
{
PortChecker checker = new PortChecker();
checker.InstallHost(host);
Port portToCheck = new Port(port, System.Net.Sockets.ProtocolType.Tcp);
PortState actual = checker.CheckPort(portToCheck);
Assert.Equal(expect, actual);
}
private int getNextFreePort()
{
while (currentPort <= MAX_PORT && !PortChecker.CheckIfPortIsOpen(currentPort))
{
currentPort++;
}
if (currentPort > MAX_PORT)
{
throw new Exception("Exceeded range of ports!");
}
return(currentPort);
}
public void CheckPort_ShouldSetOpenedBecauseTcpPortIsZero()
{
int expectPort = 0;
PortState expectState = PortState.Opened;
PortChecker checker = new PortChecker();
checker.InstallHost("localhost");
Port port = new Port();
PortState actual = checker.CheckPort(port);
Assert.Equal(expectPort, port.Value);
Assert.Equal(expectState, actual);
}
public ClusterServer()
{
Console.WriteLine("Test if port 28000 is in use...");
if (PortChecker.IsPortAvailable(28000))
{
Console.WriteLine("Port 28000 is already in use - You can only run one login server on one computer");
return;
}
Rijndael.Initiate();
Config = new ClusterServerConfig("Resources/Config/Cluster.ini");
int loginPort = (int)Config.GetSetting("LoginPort");
Console.WriteLine("Test if port {0} is in use...", loginPort.ToString());
if (PortChecker.IsPortAvailable(loginPort))
{
Console.WriteLine("Port {0} is already in use - You can only run one login server on one computer", loginPort);
return;
}
int receivePort = (int)Config.GetSetting("InterserverPort");
Console.WriteLine("Search open port for interserver connection...");
while (PortChecker.IsPortAvailable(receivePort))
{
Console.WriteLine("Port {0} not available", receivePort.ToString());
receivePort += 1;
}
LoginDatabase = new LoginDatabase(Config);
ClusterDatabase = new ClusterDatabase(Config);
if (ClusterDatabase.Connection.CheckConnection() && LoginDatabase.Connection.CheckConnection())
{
Console.WriteLine("Connecting to login server...");
LoginConnector = new LoginConnector(loginPort.ToString(), receivePort.ToString());
LoginConnector.StartListening();
// Let's wait a bit to let the subscriber and publisher socket to connect
Thread.Sleep(500);
RegisterClusterRequest request = new RegisterClusterRequest((uint)Config.GetSetting("ClusterId"), (string)Config.GetSetting("ClusterAuthorizationPassword"), (string)Config.GetSetting("ClusterAddress"), receivePort.ToString(), LoginConnector.PublisherSocket);
LoginConnector.OnClusterRequestSuccesful += new LoginConnector.RequestSuccesfulHandler(OnRegisterClusterRequestSuccesful);
}
}
public LoginServer()
{
Console.WriteLine("Test if port 23000 is in use...");
if (PortChecker.IsPortAvailable(23000))
{
Console.WriteLine("Port 23000 is already in use - You can only run one cluster on one computer");
return;
}
Config = new LoginServerConfig("Resources/Config/Login.ini");
int loginPort = (int)Config.GetSetting("LoginPort");
Console.WriteLine("Test if port {0} is in use...", loginPort.ToString());
if (PortChecker.IsPortAvailable(loginPort))
{
Console.WriteLine("Port {0} is already in use - You can only run one login server on one computer", loginPort);
return;
}
LoginDatabase = new LoginDatabase(Config);
if (LoginDatabase.Connection.CheckConnection())
{
Rijndael.Initiate();
this.m_ClusterConnector = new ClusterConnector(loginPort.ToString());
this.m_ClusterConnector.StartListening();
ClusterManager = new ClusterManager();
Console.WriteLine("Listening for cluster servers...");
this.m_ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.m_ClientSocket.Bind(new IPEndPoint(IPAddress.Any, 23000));
this.m_ClientSocket.Listen(100);
ClientManager = new ClientManager();
Thread acceptClientsThread = new Thread(() => ClientManager.AcceptUsers(this.m_ClientSocket));
acceptClientsThread.Start();
Thread processClientsThread = new Thread(() => ClientManager.ProcessUsers());
processClientsThread.Start();
Console.WriteLine("Listening for clients...");
}
}
internal static void CheckNetwork()
{
//Check to see if AGD can see this server. If so let the owner know :)
if (Options.OpenPortChecker && !Context.StartupOptions.NoNetworkCheck)
{
var serverAccessible = PortChecker.CanYouSeeMe(Options.ServerPort, out var externalIp);
Console.WriteLine(Strings.Portchecking.connectioninfo);
if (!string.IsNullOrEmpty(externalIp))
{
Console.WriteLine(Strings.Portchecking.publicip, externalIp);
Console.WriteLine(Strings.Portchecking.publicport, Options.ServerPort);
Console.WriteLine();
if (serverAccessible)
{
Console.WriteLine(Strings.Portchecking.accessible);
Console.WriteLine(Strings.Portchecking.letothersjoin);
}
else
{
Console.WriteLine(Strings.Portchecking.notaccessible);
Console.WriteLine(Strings.Portchecking.debuggingsteps);
Console.WriteLine(Strings.Portchecking.checkfirewalls);
Console.WriteLine(Strings.Portchecking.checkantivirus);
Console.WriteLine(Strings.Portchecking.screwed);
Console.WriteLine();
if (!UpnP.ForwardingSucceeded())
{
Console.WriteLine(Strings.Portchecking.checkrouterupnp);
}
}
}
else
{
Console.WriteLine(Strings.Portchecking.notconnected);
}
Console.WriteLine();
}
}
public void CheckStatus()
{
Task t = Task.Run(() =>
{ //Prevents Lock of Form
try
{
Parallel.ForEach(ips, (x) => //does parallel but only exit after all finished
{
if (x.Last_Checked == null || (x.Last_Checked + TimeSpan.FromSeconds(cycleTime) < DateTime.Now && x.RunningCheck == false))
{//Never checked or last Check older than cycleTime
x.RunningCheck = true;
x.Last_Checked = DateTime.Now;
PingReply reply = Pinger.PingIP(x.IP_Address.ToString(), timeout); //new PingReply();
if (reply != null)
{//Ping is not null (means success or not)
string hostname = "";
if (cbHostnames.Checked == true && x.Hostname != null)
{ //Resolve hostname is enabled
hostname = Hostname.Get(x.IP_Address.ToString());
x.Hostname = hostname;
}
bool online = false;
if (reply.Status == IPStatus.Success)
{//Host is online
online = true;
if (x.First_Seen == null)
{
x.First_Seen = DateTime.Now;
}
x.Roundtrip = Convert.ToInt32(reply.RoundtripTime);
x.Last_Seen = DateTime.Now;
if (port != 0)
{
x.PortOpen = PortChecker.ScanPort(x.IP_Address, port);
}
}
if (x.Active == false && online == true)
{//Host Status changed from offline to online
//New Host
if (port != 0)
{
messageBox.Push("NEW: " + x.IP_Address + ", " + x.Hostname + " First Seen: " + x.First_Seen + " Port " + port + ": " + x.PortOpen);
}
else
{
messageBox.Push("NEW: " + x.IP_Address + ", " + x.Hostname + " First Seen: " + x.First_Seen);
}
}
else if (x.Active == true && online == false)
{//Host Status changed from online to offline
if (port != 0)
{
messageBox.Push("DISAPPEARED: " + x.IP_Address + ", " + x.Hostname + " Last Seen: " + x.Last_Seen + " Port " + port + ": " + x.PortOpen);
}
else
{
messageBox.Push("DISAPPEARED: " + x.IP_Address + ", " + x.Hostname + " Last Seen: " + x.Last_Seen);
}
}
x.Last_Checked = DateTime.Now;
x.Active = online;
x.CountChecks++;
x.RunningCheck = false;
}
}
});
}
catch (System.AggregateException e)
{
throw e;
}
});
UpdateMessage();
}
private void SerPort_Event(object sender, EventArgs e)
{
EventArgs ee = new EventArgs();
PortChecker.OnTick(ee);
}
/// <summary>
/// Completes an async event to receive data.
/// </summary>
/// <param name="result"></param>
private void OnServerReceiveData(IAsyncResult result)
{
// Prevent invalid calls to this function.
if (!this._isRunning || result.IsCompleted == false || !(result.AsyncState is Socket))
{
this.Stop();
return;
}
Socket server = ((Socket)result.AsyncState);
// Attempt to end the async call.
int nRecvCount = 0;
try
{
try
{
nRecvCount = server == null ? 0 : server.EndReceive(result);
}
catch
{
// TODO: atleast log the exception.
}
if (nRecvCount == 0)
{
this.Stop();
return;
}
}
catch (Exception ex)
{
log.Debug(ex.ToString());
this.Stop();
return;
}
// Read the current packet.
byte[] recvData = new byte[nRecvCount];
Array.Copy(this._serverBuffer, 0, recvData, 0, nRecvCount);
this._serverBacklog.AddRange(recvData);
// Iterate through the whole received stream, identify packets, parse them and delete them from the buffer.
while (true)
{
/*
* L2Packet structure:
| 2 byte size | 1 byte id | up to 65535 bytes for data (payload) |
*/
// If packet buffer is lesser than 3 bytes there is no valid packet for parsing (the minimum is atleast 3 bytes (2 bytes for size, 1 for id)
if (this._serverBacklog.Count < 3)
{
break;
}
while (L2Injector._sgObjInit == false)
{
Thread.Sleep(20);
}
// Calculate the packet length by parsing the first 2 bytes.
int nPacketSize = BitConverter.ToUInt16(this._serverBacklog.ToArray(), 0);
if (this._serverBacklog.Count < nPacketSize)
{
break;
}
byte[] receivedPacket = new byte[nPacketSize];
Array.Copy(this._serverBacklog.ToArray(), 0, receivedPacket, 0, nPacketSize);
this._serverBacklog.RemoveRange(0, nPacketSize);
// Send this packet to the client..
if (isAuth)
{
_blowfishDecypher.decryptBlock(receivedPacket, 2, receivedPacket, 2);
}
if (this.isAuth && receivedPacket[2] != 4)
{
_blowfishDecypher.encryptBlock(receivedPacket, 2, receivedPacket, 2);
this.SendToClientRaw(receivedPacket);
}
else if (isAuth)
{
_blowfishDecypher.encryptBlock(receivedPacket, 2, receivedPacket, 2);
}
int asd = 0;
// TODO: Get rid of this control flow.
if (isAuth)
{
if (!_isInit)
{
// Decipher the initial packet with the static blowfish key.
_blowfishDecypher.setKey(Blowfish.StaticKey);
for (int i = 0; i < receivedPacket.Length - 2; i += 8)
{
_blowfishDecypher.decryptBlock(receivedPacket, 2 + i, receivedPacket, 2 + i);
}
// Remove the xor mask.
int xorKey = receivedPacket[receivedPacket.Length - 8] |
(receivedPacket[receivedPacket.Length - 7] << 8) |
(receivedPacket[receivedPacket.Length - 6] << 16) |
(receivedPacket[receivedPacket.Length - 5] << 24);
Blowfish.RemoveXorMask(receivedPacket, ref xorKey);
//Blowfish.ApplyXorMask(receivedPacket, ref xorKey);
// Extract the new blowfish key for the rest of the authentification communication.
byte[] dynamicKey = new byte[16];
Array.Copy(receivedPacket, 155, dynamicKey, 0, 16);
// Cypher the packet again.
for (int i = 0; i < receivedPacket.Length - 2; i += 8)
{
_blowfishDecypher.encryptBlock(receivedPacket, 2 + i, receivedPacket, 2 + i);
}
// Set the newly acquired blowfish key from the server.
_blowfishDecypher.setKey(dynamicKey);
_isInit = true;
}
else
{
for (int i = 0; i < receivedPacket.Length - 2; i += 8)
{
_blowfishDecypher.decryptBlock(receivedPacket, 2 + i, receivedPacket, 2 + i);
}
if (receivedPacket[2] == 4)
{
//Restore default connect procedure, so client can connect to our proxied servers.
L2Injector.RestoreHookedBytes();
int serverCount = receivedPacket[3];
int serverBlock = 21;
for (int i = 0; i < serverCount; i++)
{
var remoteIp = receivedPacket[6 + i * serverBlock] + "." +
receivedPacket[7 + i * serverBlock] + "." +
receivedPacket[8 + i * serverBlock] + "." +
receivedPacket[9 + i * serverBlock];
var remotePort = receivedPacket[10 + i * serverBlock] |
(receivedPacket[11 + i * serverBlock] << 8);
bool isHosted = false;
int localPort = PortChecker.GetOpenPort();
//Check if this game server is already hosted
foreach (var gserver in Server.GameServers)
{
if (remoteIp == gserver.RemoteAddress && gserver.BotInstance == BotInstance)
{
isHosted = true;
localPort = gserver.LocalPort;
}
}
if (!isHosted)
{
//brazil hack
//if (remoteIp == "181.119.6.72")
// remotePort = 7779;
//if (remoteIp == "45.126.211.94")
// remotePort = 7779;
Server gameServer = new Server
{
IsAuthServer = false,
LocalAddress = "127.0.0.1", //localhost
LocalPort = localPort,
//this will result in the default game port (7777) - server id (ex. 16 for naia) = 7761 (thus avoiding conflicts)
RemoteAddress = remoteIp, //current naia game server ip
RemotePort = remotePort, //7777
ServerId = receivedPacket[5 + i * serverBlock],
L2Injector = L2Injector,
BotInstance = this.BotInstance
};
gameServer.Start();
//log.Debug($"{remoteIp}:{remotePort}");
Server.GameServers.Add(gameServer);
}
// Modifying the packet to point to our proxys.
string[] ipParts = "127.0.0.1".Split('.');
receivedPacket[6 + i * serverBlock] = byte.Parse(ipParts[0]);
receivedPacket[7 + i * serverBlock] = byte.Parse(ipParts[1]);
receivedPacket[8 + i * serverBlock] = byte.Parse(ipParts[2]);
receivedPacket[9 + i * serverBlock] = byte.Parse(ipParts[3]);
receivedPacket[10 + i * serverBlock] = (byte)(localPort & 0xff);
receivedPacket[11 + i * serverBlock] = (byte)((localPort >> 8) & 0xff);
}
}
for (int i = 0; i < receivedPacket.Length - 2; i += 8)
{
_blowfishDecypher.encryptBlock(receivedPacket, 2 + i, receivedPacket, 2 + i);
}
_blowfishDecypher.decryptBlock(receivedPacket, 2, receivedPacket, 2);
if (receivedPacket[2] == 4)
{
_blowfishDecypher.encryptBlock(receivedPacket, 2, receivedPacket, 2);
this.SendToClientRaw(receivedPacket);
}
}
}
else
{
if (!_isInit)
{
byte[] dynamicKeyBytes = new byte[8];
//receivedPacket[4] = 0;
//receivedPacket[5] = 0;
//receivedPacket[6] = 0;
//receivedPacket[7] = 0;
//receivedPacket[8] = 0;
//receivedPacket[9] = 0;
//receivedPacket[10] = 0;
//receivedPacket[11] = 0;
Array.Copy(receivedPacket, 4, dynamicKeyBytes, 0, 8);
//int seed = BitConverter.ToInt32(receivedPacket.ToArray(), 21);
if (JUSTASNIFFER)
{
log.Debug(BitConverter.ToInt64(dynamicKeyBytes, 0));
log.Debug(string.Join(", ", dynamicKeyBytes.Select(b => string.Format("{0:X2} ", b))));
}
_gamePacketObfuscator = new LegacyInGameCipher(dynamicKeyBytes, 0);
if (!L2Injector.IsSGLoaded())
{
_isInit = true;
}
}
else
{
lock (syncLock2)
{
_gamePacketObfuscator.DeobfuscatePacketFromServer(receivedPacket);
_secondaryGamePacketObfuscator?.DeobfuscatePacketFromServer(receivedPacket);
//log.Debug(string.Join(", ", receivedPacket.Select(b => string.Format("{0:X2} ", b))));
//PacketParser.HandleIncomingPacket(receivedPacket, this.data, this.logger);
if (!JUSTASNIFFER)
{
var packet = packetFactory.CreatePacket(receivedPacket, true);
packet?.Parse(BotInstance.PlayerData);
//if(packet == null && receivedPacket[2] != 74)
//log.Debug(receivedPacket[2]);
}
_secondaryGamePacketObfuscator?.ObfuscatePacketForClient(receivedPacket);
_gamePacketObfuscator.ObfuscatePacketForClient(receivedPacket);
}
}
}
if (!this.isAuth && receivedPacket != null)
{
lock (syncLock)
{
this.SendToClientRaw(receivedPacket);
}
}
}
// Begin listening for next packet.
this.Server_BeginReceive();
}
