[C#] AntiDumpers - Защита от дампа

[r3xq1]

Для начала создаём класс SafeNativeMethods.cs
Запишем в него импорт VirtualProtect из библиотеки kernel32.dll

namespace DarkScript
{
    using System.Runtime.InteropServices;

    internal static class SafeNativeMethods
    {
        [DllImport("kernel32.dll")]
        public static extern unsafe bool VirtualProtect(byte* lpAddress, int dwSize, uint flNewProtect, out uint lpflOldProtect);
    }
}

Далее создадим класс Protect.cs и запишем в него данный код:

namespace DarkScript
{
    using System;
    using System.Runtime.InteropServices;

    internal static class Protect
    {
        public static unsafe void Initialize()
        {
            byte* ptr = (byte*)(void*)Marshal.GetHINSTANCE(typeof(Protect).Module);
            byte* ptr2 = ptr + 60;
            ptr2 = ptr + *(uint*)ptr2;
            ptr2 += 6;
            ushort num = *(ushort*)ptr2;
            ptr2 += 14;
            ushort num2 = *(ushort*)ptr2;
            ptr2 = ptr2 + 4 + num2;
            SafeNativeMethods.VirtualProtect(ptr2 - 16, 8, 64U, out uint num3);
            *(int*)(ptr2 - 12) = 0;
            byte* ptr3 = ptr + *(uint*)(ptr2 - 16);
            *(int*)(ptr2 - 16) = 0;
            SafeNativeMethods.VirtualProtect(ptr3, 72, 64U, out num3);
            byte* ptr4 = ptr + *(uint*)(ptr3 + 8);
            *(int*)ptr3 = 0;
            *(int*)(ptr3 + 4) = 0;
            *(int*)(ptr3 + 8) = 0;
            *(int*)(ptr3 + 12) = 0;
            SafeNativeMethods.VirtualProtect(ptr4, 4, 64U, out num3);
            *(int*)ptr4 = 0;
            for (int i = 0; i < num; i++)
            {
                SafeNativeMethods.VirtualProtect(ptr2, 8, 64U, out num3);
                Marshal.Copy(new byte[8], 0, (IntPtr)(void*)ptr2, 8);
                ptr2 += 40;
            }
        }
    }
}

Далее просто вызываем метод Initialize() из класса Protect.cs

Protect.Initialize();

При попытке сдампить приложение, ничего не получаем)

 

[уруру]

ну ты бы хоть комментарии в коде оставил. где что означает итд

 

[Pernat1y]

Туториал из серии "как нарисовать сову за 2 шага"

 

[Naraku]

Если это способ, то можно было бы и комментарии оставить, чтобы случайный путник не просто did copy paste, а еще и в голову себе что-то отложил с этого.
Поправь, если я что-то угадал неверно.

Спойлер

namespace DarkScript
{
    using System;
    using System.Runtime.InteropServices;

    internal static class Protect
    {
        public static unsafe void Initialize()
        {
            byte* ptr = (byte*)(void*)Marshal.GetHINSTANCE(typeof(Protect).Module); //получаем базовый адрес.
            byte* ptr2 = ptr + 60; // смещаемся до e_lfanew
            ptr2 = ptr + *(uint*)ptr2; //топаем в File Header
            ptr2 += 6; // Смещаемся до NumberOfSection
            ushort num = *(ushort*)ptr2; //получаем кол-во секций
            ptr2 += 14; //смещаемся до поля с размером опционального заголовка
            ushort num2 = *(ushort*)ptr2; // получаем размер опционального заголовка
            ptr2 = ptr2 + 4 + num2; // огибаем опциональный заголовок
            SafeNativeMethods.VirtualProtect(ptr2 - 16, 8, 64U, out uint num3); //ставим защиту PAGE_EXECUTEREADWRITE чтобы иметь возможность писать в участок памяти
            *(int*)(ptr2 - 12) = 0; //обнуляем размер .NET MetaData
            byte* ptr3 = ptr + *(uint*)(ptr2 - 16); // указатель на .Net Directory
            *(int*)(ptr2 - 16) = 0; //обнуляем указатель на .NET Directory
            SafeNativeMethods.VirtualProtect(ptr3, 72, 64U, out num3); //set read/write/execute protect
            byte* ptr4 = ptr + *(uint*)(ptr3 + 8); //получаем указатель на MetaData
            *(int*)ptr3 = 0; //обнуляем MajorRuntimeVersion
            *(int*)(ptr3 + 4) = 0; //обнуляем MinorRuntimeVersion
            *(int*)(ptr3 + 8) = 0; //Обнуляем указатель на MetaData
            *(int*)(ptr3 + 12) = 0; //Обнуляем размер MetaData
            SafeNativeMethods.VirtualProtect(ptr4, 4, 64U, out num3); //ставим доступную защиту на сигнатуру в MetaData Header
            *(int*)ptr4 = 0; //обнуляем эту сигнатуру
            for (int i = 0; i < num; i++) //перебираем все записи в таблице секций.
            {
                SafeNativeMethods.VirtualProtect(ptr2, 8, 64U, out num3); //ставим новую защиту, чтобы мы могли писать в память
                Marshal.Copy(new byte[8], 0, (IntPtr)(void*)ptr2, 8); //Обнуляем запись о секции в таблице секций
                ptr2 += 40; //переходим к следующей секции в таблице секций.
            }
        }
    }
}

Кстати, неплохо бы возвращать старую защиту на регионы памяти после манипуляций с ними.

 

[Selfie]

Если это способ, то можно было бы и комментарии оставить, чтобы случайный путник не просто did copy paste, а еще и в голову себе что-то отложил с этого.
Поправь, если я что-то угадал неверно.

Спойлер

namespace DarkScript
{
    using System;
    using System.Runtime.InteropServices;

    internal static class Protect
    {
        public static unsafe void Initialize()
        {
            byte* ptr = (byte*)(void*)Marshal.GetHINSTANCE(typeof(Protect).Module); //получаем базовый адрес.
            byte* ptr2 = ptr + 60; // смещаемся до e_lfanew
            ptr2 = ptr + *(uint*)ptr2; //топаем в File Header
            ptr2 += 6; // Смещаемся до NumberOfSection
            ushort num = *(ushort*)ptr2; //получаем кол-во секций
            ptr2 += 14; //смещаемся до поля с размером опционального заголовка
            ushort num2 = *(ushort*)ptr2; // получаем размер опционального заголовка
            ptr2 = ptr2 + 4 + num2; // огибаем опциональный заголовок
            SafeNativeMethods.VirtualProtect(ptr2 - 16, 8, 64U, out uint num3); //ставим защиту PAGE_EXECUTEREADWRITE чтобы иметь возможность писать в участок памяти
            *(int*)(ptr2 - 12) = 0; //обнуляем размер .NET MetaData
            byte* ptr3 = ptr + *(uint*)(ptr2 - 16); // указатель на .Net Directory
            *(int*)(ptr2 - 16) = 0; //обнуляем указатель на .NET Directory
            SafeNativeMethods.VirtualProtect(ptr3, 72, 64U, out num3); //set read/write/execute protect
            byte* ptr4 = ptr + *(uint*)(ptr3 + 8); //получаем указатель на MetaData
            *(int*)ptr3 = 0; //обнуляем MajorRuntimeVersion
            *(int*)(ptr3 + 4) = 0; //обнуляем MinorRuntimeVersion
            *(int*)(ptr3 + 8) = 0; //Обнуляем указатель на MetaData
            *(int*)(ptr3 + 12) = 0; //Обнуляем размер MetaData
            SafeNativeMethods.VirtualProtect(ptr4, 4, 64U, out num3); //ставим доступную защиту на сигнатуру в MetaData Header
            *(int*)ptr4 = 0; //обнуляем эту сигнатуру
            for (int i = 0; i < num; i++) //перебираем все записи в таблице секций.
            {
                SafeNativeMethods.VirtualProtect(ptr2, 8, 64U, out num3); //ставим новую защиту, чтобы мы могли писать в память
                Marshal.Copy(new byte[8], 0, (IntPtr)(void*)ptr2, 8); //Обнуляем запись о секции в таблице секций
                ptr2 += 40; //переходим к следующей секции в таблице секций.
            }
        }
    }
}

Кстати, неплохо бы возвращать старую защиту на регионы памяти после манипуляций с ними.

ТС не понимает, что делает данный код в техническом плане. Он скопипастил его с ConfuserEx.