public ListenerHttp StartHttpListener(NewHttpListenerRequest request, AgentController agentController, CryptoController cryptoController, string user)
{
var listener = new ListenerHttp
{
ListenerName = request.Name,
Type = ListenerType.HTTP,
BindPort = request.BindPort,
ConnectAddress = request.ConnectAddress,
ConnectPort = request.ConnectPort
};
var module = new HttpCommModule
{
Listener = listener
};
HttpListeners.Add(module);
module.Init(agentController, cryptoController);
module.Start();
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.ListenerStarted, request.Name));
Log.Logger.Information("LISTENER {Event} {ListenerName} {Nick}", ServerEventType.ListenerStarted.ToString(), request.Name, user);
return(listener);
}
public void UnregisterServerEvent(OnServerEvent callback)
{
if (onServerEvent != null)
{
onServerEvent -= callback;
}
}
public void RegisterServerModule(IServerModule module)
{
module.Init(this, AgentController);
var info = module.GetModuleInfo();
ServerModules.Add(info);
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.ServerModuleRegistered, info.Name));
Log.Logger.Information("SERVER {Event} {ModuleName}", ServerEventType.ServerModuleRegistered.ToString(), info.Name);
}
public void Stop()
{
foreach (var client in connections)
{
DisconnectClient(client);
}
connections.Clear();
server.Stop();
OnServerEvent.Invoke("Server stopped.");
}
public void Start()
{
server.Start();
OnServerEvent.Invoke("Server started.");
while (true)
{
var tcpClient = server.AcceptTcpClientAsync().Result;
ConnectClientAsync(tcpClient);
}
}
private void GettingData(object[] data, Connection sender)
{
OnGetDataFromClient.Invoke(data);
var invoker = new HubInvoker();
if (!invoker.TryInvoke(data))
{
OnServerEvent.Invoke("Hub or method not found");
}
}
public void Start()
{
ServerStatus = ModuleStatus.Running;
Task.Factory.StartNew(delegate()
{
while (ServerStatus == ModuleStatus.Running)
{
var commModules = ListenerController.HttpListenerController.HttpListeners.ToList();
foreach (var commModule in commModules)
{
if (commModule != null && commModule.RecvData(out Tuple <AgentMetadata, AgentMessage> data) == true)
{
if (data != null)
{
var message = data.Item2;
if (!IdempotencyKeys.Contains(message.IdempotencyKey))
{
IdempotencyKeys.Add(message.IdempotencyKey);
var checkinCallback = ServerModules
.Where(m => m.Name.Equals("Core", StringComparison.OrdinalIgnoreCase))
.Select(m => m.ServerCommands).FirstOrDefault()
.Where(c => c.Name.Equals("AgentCheckIn", StringComparison.OrdinalIgnoreCase))
.Select(c => c.CallBack).FirstOrDefault();
// checkin the parent agent
checkinCallback?.Invoke(data.Item1, null);
// checkin the p2p agent
if (!string.IsNullOrEmpty(message.Metadata.ParentAgentID))
{
checkinCallback?.Invoke(message.Metadata, message.Data);
}
if (!message.Data.Command.Equals("AgentCheckIn", StringComparison.OrdinalIgnoreCase))
{
HandleC2Data(message.Metadata, message.Data);
}
}
else
{
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.IdempotencyKeyError, $"Duplicate Idempotency Key received for {message.Metadata.AgentID}"));
}
}
}
}
}
});
}
public bool StopTcpListener(string listenerId, string user)
{
var listener = TcpListeners.FirstOrDefault(l => l.ListenerId.Equals(listenerId));
if (listener != null)
{
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.ListenerStopped, listenerId));
Log.Logger.Information("LISTENER {Event} {ListenerName} {Nick}", ServerEventType.ListenerStopped.ToString(), listenerId, user);
}
return(TcpListeners.Remove(listener));
}
public bool StopSmbListener(string listenerName, string user)
{
var listener = SmbListeners.FirstOrDefault(l => l.ListenerName.Equals(listenerName, StringComparison.OrdinalIgnoreCase));
if (listener != null)
{
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.ListenerStopped, listenerName));
Log.Logger.Information("LISTENER {Event} {ListenerName} {Nick}", ServerEventType.ListenerStopped.ToString(), listenerName, user);
}
return(SmbListeners.Remove(listener));
}
public bool StopHttpListener(string listenerId, string user)
{
var module = HttpListeners.FirstOrDefault(m => m.Listener.ListenerName.Equals(listenerId, StringComparison.OrdinalIgnoreCase));
if (module != null)
{
module.Stop();
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.ListenerStopped, listenerId));
Log.Logger.Information("LISTENER {Event} {ListenerName} {Nick}", ServerEventType.ListenerStopped.ToString(), listenerId, user);
}
return(HttpListeners.Remove(module));
}
private void CreateSession(AgentMetadata metadata)
{
ConnectedAgents.Add(new AgentSessionData
{
Metadata = metadata,
FirstSeen = DateTime.UtcNow,
LastSeen = DateTime.UtcNow
});
var data = string.Format("{0}@{1} ({2})", metadata.Identity, metadata.IPAddress, metadata.Hostname);
OnServerEvent?.Invoke(this, new ServerEvent(ServerEventType.InitialAgent, data));
Log.Logger.Information("AGENT {Event} {AgentID} {Hostname}", ServerEventType.InitialAgent.ToString(), metadata.AgentID, metadata.Hostname);
}
//===============================================================================
public void RegisterServerEvent(OnServerEvent callback)
{
onServerEvent += callback;
}
private static void ServerEvent(object sender, EventArgs e)
{
OnServerEvent?.Invoke(typeof(ValheimServer), e);
}
