Гайд Как сделать проверку на открытые процессы в C#

chyperphunk · 17 Январь 2022

Как сделать проверку на открытые процессы в C#

Привет всем, я только начинаю и хочу показать вам работу, которую мы проделали с моим другом. В этой защите можно сделать как BSOD, так и просто закрытие процесса. Для многих людей это очень важно и не судите, что его можно обойти обычным renamer'ом, вдруг он захочет сделать эту проверку от "Not-lохи" программистов.

ЕСЛИ У ВАС БУДУТ ОШИБКИ НЕ ОБРАЩАЙТЕ ВНИМАНИЕ ПРОСТО ВСЁ СДЕЛАЙТЕ ПО ИНСТРУКЦИИ!

1)Сначала мы создаем класс с именем типа "SettingsGu.cs" (Если вы не поняли, рекомендуется делать все по инструкции), а затем пишем в нем небольшой код:

SettingsGu.cs:

using System;


namespace Launcher
{
    public class SettingsGu
    {
        //Ломать систему в BSOD при попытки реверса
        public bool IsBSOD = false;

        //Ломать процесс при попытки реверса
        public bool IsCrashProc = true;

    }
}

.

Тут мы выбираем, BSOD(Синий экран) или просто IsCrashProc(Будут закрываться деббагеры, при их обнаружении).

2) Мы открываем Process.cs и пишем туда это:

Program.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Threading;
using System.Windows.Forms;
using Launcher;

namespace Laucher
{
    static class Program
    {
        private static SettingsGu settGu = new SettingsGu();

        [STAThread]
        static void Main()
        {
          #if DEBUG

          #else
            Thread workerThread = new Thread(() =>
            {

                while (true)
                {
                    if (AntiDebug.PerformChecks() == 1)
                    {
                        if(settGu.IsCrashProc)
                        {
                            Environment.Exit(1);
                        }

                        if(settGu.IsBSOD)
                        {
                            Guard.BSOD();
                        }   
                        
                    }
                    Thread.Sleep(1000);
                }

            });

            workerThread.Start();
            workerThread.Priority = ThreadPriority.Highest;

            Thread workerThread2 = new Thread(() =>
            {

                while (true)
                {
                    Guard.InitGuard();

                    Thread.Sleep(1000);
                }

            });

            workerThread2.Start();
            workerThread2.Priority = ThreadPriority.Highest;
             #endif

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());

            #if DEBUG

            #else
            AntiDebug.HideOSThreads();

            DumpProtect.AntiDump();
            #endif


        }
    }
}

.

3) Теперь приступаем к десерту AntiDebag.cs:

AntiDebug.cs:

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Launcher
{
    public class AntiDebug
    {
        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool CheckRemoteDebuggerPresent(IntPtr hProcess, [MarshalAs(UnmanagedType.Bool)] ref bool isDebuggerPresent);

        [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsDebuggerPresent();

        [DllImport("ntdll.dll", SetLastError = true, ExactSpelling = true)]
        internal static extern NtStatus NtQueryInformationProcess([In] IntPtr ProcessHandle, [In] PROCESSINFOCLASS ProcessInformationClass, out IntPtr ProcessInformation, [In] int ProcessInformationLength, [Optional] out int ReturnLength);

        [DllImport("ntdll.dll", SetLastError = true, ExactSpelling = true)]
        internal static extern NtStatus NtClose([In] IntPtr Handle);

        [DllImport("ntdll.dll", SetLastError = true, ExactSpelling = true)]
        internal static extern NtStatus NtRemoveProcessDebug(IntPtr ProcessHandle, IntPtr DebugObjectHandle);

        [DllImport("ntdll.dll", SetLastError = true, ExactSpelling = true)]
        internal static extern NtStatus NtSetInformationDebugObject([In] IntPtr DebugObjectHandle, [In] DebugObjectInformationClass DebugObjectInformationClass, [In] IntPtr DebugObjectInformation, [In] int DebugObjectInformationLength, [Out][Optional] out int ReturnLength);

        [DllImport("ntdll.dll", SetLastError = true, ExactSpelling = true)]
        internal static extern NtStatus NtQuerySystemInformation([In] SYSTEM_INFORMATION_CLASS SystemInformationClass, IntPtr SystemInformation, [In] int SystemInformationLength, [Out][Optional] out int ReturnLength);

        static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);

        [DllImport("ntdll.dll")]
        internal static extern NtStatus NtSetInformationThread(IntPtr ThreadHandle, ThreadInformationClass ThreadInformationClass, IntPtr ThreadInformation, int ThreadInformationLength);

        [DllImport("kernel32.dll")]
        static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, uint dwThreadId);

        [DllImport("kernel32.dll")]
        static extern uint SuspendThread(IntPtr hThread);

        [DllImport("kernel32.dll")]
        static extern int ResumeThread(IntPtr hThread);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern bool CloseHandle(IntPtr handle);

        private static readonly SettingsGu settGu = new SettingsGu();

        public static void HideOSThreads()
        {
            ProcessThreadCollection currentThreads = Process.GetCurrentProcess().Threads;

            foreach (ProcessThread thread in currentThreads)
            {
                IntPtr pOpenThread = OpenThread(ThreadAccess.SET_INFORMATION, false, (uint)thread.Id);

                if (pOpenThread == IntPtr.Zero)
                {
                    continue;
                }

                if (HideFromDebugger(pOpenThread))
                {

                }

                CloseHandle(pOpenThread);
            }
        }

        public static bool HideFromDebugger(IntPtr Handle)
        {
            NtStatus nStatus = NtSetInformationThread(Handle, ThreadInformationClass.ThreadHideFromDebugger, IntPtr.Zero, 0);

            if (nStatus == NtStatus.Success)
            {
                return true;
            }

            return false;
        }

        public static int PerformChecks()
        {
            if (CheckDebuggerManagedPresent() == 1)
            {
                return 1;
            }

            if (CheckDebuggerUnmanagedPresent() == 1)
            {
                return 1;
            }

            if (CheckRemoteDebugger() == 1)
            {
                return 1;
            }

            if (CheckDebugPort() == 1)
            {
                return 1;
            }

            if (CheckKernelDebugInformation())
            {
                return 1;
            }

            if (DetachFromDebuggerProcess())
            {
                return 1;
            }

            return 0;
        }

        private static int CheckDebuggerUnmanagedPresent()
        {
            if (IsDebuggerPresent())
            {
                return 1;
            }

            return 0;
        }

        private static int CheckDebuggerManagedPresent()
        {
            if (Debugger.IsAttached)
            {
                return 1;
            }

            return 0;
        }

        private static int CheckRemoteDebugger()
        {
            var isDebuggerPresent = (bool)false;

            var bApiRet = CheckRemoteDebuggerPresent(Process.GetCurrentProcess().Handle, ref isDebuggerPresent);

            if (bApiRet && isDebuggerPresent)
            {
                return 1;
            }

            return 0;
        }

        private static int CheckDebugPort()
        {
            NtStatus status;
            IntPtr DebugPort = new IntPtr(0);
            int ReturnLength;

            unsafe
            {
                status = NtQueryInformationProcess(Process.GetCurrentProcess().Handle, PROCESSINFOCLASS.ProcessDebugPort, out DebugPort, Marshal.SizeOf(DebugPort), out ReturnLength);

                if (status == NtStatus.Success)
                {
                    if (DebugPort == new IntPtr(-1))
                    {
                        return 1;
                    }
                }
            }

            return 0;
        }


        private static bool DetachFromDebuggerProcess()
        {
            IntPtr hDebugObject = INVALID_HANDLE_VALUE;
            var dwFlags = 0U;
            NtStatus ntStatus;
            int retLength_1;
            int retLength_2;

            unsafe
            {
                ntStatus = NtQueryInformationProcess(Process.GetCurrentProcess().Handle, PROCESSINFOCLASS.ProcessDebugObjectHandle, out hDebugObject, IntPtr.Size, out retLength_1);

                if (ntStatus != NtStatus.Success)
                {

                    return false;
                }

                ntStatus = NtSetInformationDebugObject(hDebugObject, DebugObjectInformationClass.DebugObjectFlags, new IntPtr(&dwFlags), Marshal.SizeOf(dwFlags), out retLength_2);

                if (ntStatus != NtStatus.Success)
                {

                    return false;
                }

                ntStatus = NtRemoveProcessDebug(Process.GetCurrentProcess().Handle, hDebugObject);

                if (ntStatus != NtStatus.Success)
                {

                    return false;
                }

                ntStatus = NtClose(hDebugObject);

                if (ntStatus != NtStatus.Success)
                {

                    return false;
                }
            }

            return true;
        }

        private static bool CheckKernelDebugInformation()
        {
            SYSTEM_KERNEL_DEBUGGER_INFORMATION pSKDI;

            int retLength;
            NtStatus ntStatus;

            unsafe
            {
                ntStatus = NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS.SystemKernelDebuggerInformation, new IntPtr(&pSKDI), Marshal.SizeOf(pSKDI), out retLength);

                if (ntStatus == NtStatus.Success)
                {
                    if (pSKDI.KernelDebuggerEnabled && !pSKDI.KernelDebuggerNotPresent)
                    {
                        return true;
                    }
                }
            }

            return false;
        }
    }
}

.

4) И самое главное название этих, самых отладчиков и если наша программа их обнаружит, то произойдет краш или bsod (Также добавляется для вашей программы проверка на Admin и не только ) :

Guard.cs:

using Microsoft.Win32;
using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Security.Principal;

namespace Launcher
{
    public class Guard
    {

        [DllImport("ntdll.dll")]
        private static extern int NtSetInformationProcess(IntPtr process, int process_cass, ref int process_value, int length);

        private readonly static SettingsGu settingsGu = new SettingsGu();

        public static void InitGuard()
        {
            NotAdmin();
            CheckerProcessIsBlacklist();
        }
        private static bool IsAdministrator()
        {
            var identity = WindowsIdentity.GetCurrent();
            var principal = new WindowsPrincipal(identity);
            return principal.IsInRole(WindowsBuiltInRole.Administrator);
        }

        public static void BSOD()
        {
            Process.EnterDebugMode();
            int status = 1;
            NtSetInformationProcess(Process.GetCurrentProcess().Handle, 0x1D, ref status, sizeof(int));
            Process.GetCurrentProcess().Kill();
        }

        private static void NotAdmin()
        {
            if (!Guard.IsAdministrator())
            {
                Directory.CreateDirectory("C:/ProgramData/IiiIiiIiII");
                File.Create($"C:/ProgramData/IiiIiiIiII/ADMIiiIiIIIi");
                Environment.Exit(1);
            }
        }

        private static void CheckerProcessIsBlacklist()
        {
            string[] array = ProcBlacklist();

            foreach (Process process in Process.GetProcesses())
            {
                if (process != Process.GetCurrentProcess())
                {
                    for (int i = 0; i < array.Length; i++)
                    {
                        if (process.ProcessName.ToLower().Contains(array[i]))
                        {
                            if (settingsGu.IsCrashProc)
                            {
                                Environment.Exit(1);
                            }

                            if (settingsGu.IsBSOD)
                            {
                                BSOD();
                            }
                        }

                        if (process.MainWindowTitle.ToLower().Contains(array[i]))
                        {
                            if (settingsGu.IsCrashProc)
                            {
                                Environment.Exit(1);
                            }

                            if (settingsGu.IsBSOD)
                            {
                                BSOD();
                            }
                        }

                        if (process.MainWindowHandle.ToString().ToLower().Contains(array[i]))
                        {
                            if (settingsGu.IsCrashProc)
                            {
                                Environment.Exit(1);
                            }

                            if (settingsGu.IsBSOD)
                            {
                                BSOD();
                            }
                        }
                    }

                }
            }

            static string[] ProcBlacklist()
            {
                return new string[]
                                {
                "procmon64",
                "pizza",
                "ida",
                "de4dot",
                "sharpod",
                "x32_dbg",
                "x64_dbg",
                "ilspy",
                "graywolf",
                "megadumper",
                "x64netdumper",
                "hxd",
                "petools",
                "protection_id",
                "ollydbg",
                "x32dbg",
                "x64dbg",
                "charles",
                "dnspy",
                "peek",
                "httpanalyzer",
                "httpdebug",
                "fiddler",
                "wireshark",
                "proxifier",
                "mitmproxy",
                "WPE PRO",
                "ghidra",
                "ollydbg",
                "ida -",
                "charles",
                "dnspy",
                "simpleassembly",
                "peek",
                "httpanalyzer",
                "httpdebug",
                "fiddler",
                "wireshark",
                "dbx",
                "mdbg",
                "gdb",
                "windbg",
                "dbgclr",
                "kdb",
                "kgdb",
                "mdb",
                "de4dotmodded",
                "StringDecryptor",
                "Centos",
                "SAE"
                };
            }
        }
    }
}

.

На данный момент это не полная защита, ее очень и очень мало, но если кинуть Themida + VMP + проверка на процессы то нормально, но если человек разбирается, то он запустит ренеймер и откроет отладчик. Извините если что то неграмотно объясняю свой первый гайд и приму вашу критику положительно![/i][/i][/i]

LiSPRISENOK · 4 Февраль 2022

Спасибо

chyperphunk · 5 Февраль 2022

LiSPRISENOK написал(а):
Спасибо

Не за что!

F0RQU1N · 14 Февраль 2022

только вот толку от этого нету, очень легко обходится

Kaidoz · 2 Июнь 2022

копипаста под чистую, которую автор видимо даже сам на деле не проверял. отсутствует enum'ы, без которых код не будет работать(придется гуглить). также автор забыл сказать, что все запущенные AntiDebug(и все остальное) функции могут сказать на некорректной работе приложения

Гайд Как сделать проверку на открытые процессы в C#

Похожие темы