.NET Reactor — это мощный инструмент для защиты исполняемых файлов, написанных на С#, от декомпиляции и обратного инжиниринга. Он предоставляет различные методы обфускации и лицензирования, обеспечивая безопасность интеллектуальной собственности разработчиков.

Но, как это обычно бывает, применяется он не только в благих целях: экспертам антивирусной лаборатории PT ESC часто попадаются вредоносные файлы, защищенные от анализа именно .Net Reactor.

🔓 Как защищен?

.NET Reactor использует несколько уровней защиты для предотвращения декомпиляции и анализа кода:

• NecroBit IL Code Protection: заменяет CIL-код методов на зашифрованный, делая невозможной декомпиляцию и восстановление исходного кода.

• Виртуализация кода: преобразует исходный код в набор инструкций отличный от .NET IL, которые интерпретируются во время выполнения виртуальной машиной, что затрудняет анализ и восстановление оригинального кода.

• Обфускация потока управления (Control Flow Obfuscation): преобразует код методов в запутанную структуру, усложняя понимание логики программы и затрудняя работу декомпиляторов (пример — на скриншоте 1).

• Шифрование строк (String Encryption): шифрует строки в коде, предотвращая их чтение и анализ, что усложняет понимание функциональности приложения, как показано на скриншоте 2.

• Антиотладочные механизмы (Anti Debug): внедряет проверки на наличие отладчиков, завершая процесс при их обнаружении, что препятствует динамическому анализу приложения.

🆕 Что нового?

• Поддержка .NET 6.0: обеспечивает защиту для новейших приложений на этой платформе.

• Улучшения в виртуализации кода и Control Flow Obfuscation обеспечивают дальнейшее повышение надежности и сложности обфускации.

• Скрытие содержимого объединенных приложений .NET Core, 5.0, 6.0 предотвращает просмотр содержимого с помощью инструментов, таких как ILSpy / dnSpy.

🧐 Как анализировать?

Несмотря на сложность защиты, существуют инструменты, которые облегчают жизнь реверсерам.
NETReactorSlayer — мощный инструмент для реверса приложений, обфусцированных с помощью .NET Reactor. Его главные фишки:

• дешифровка NecroBit — восстанавливает CIL-код из зашифрованных методов;

• удаление прокси и оберток — очищает код от мусора, добавленного обфускатором (смотрите на скриншоте 3);

• декодирование строк и ресурсов — возвращает читаемые строки, зашифрованные в приложении;

• обход антиотладки и защиты от изменения кода.

Однако начиная с версии 6.9 изначальная версия Net Reactor Slayer перестала справляться с деобфускацией защиты даже с базовыми параметрами. Благодаря открытому исходному коду и довольно большому комьюнити, в pull requests можно найти исправленный код, который прекрасно отрабатывает даже на самой свежей версии обфускатора.

Но вот с виртуализированным кодом не все так гладко: Net Reactor Slayer с ним не справляется. Если вам повезло и файл был защищен версией 6.9.0.0, то можно не тратить время на ручной анализ виртуальной машины, а применить VMAttack — инструмент для девиртуализации приложений .NET, в котором есть поддержка этой версии .NET Reactor. А если не повезло — проще всего проанализировать файл по его поведению, например с помощью PT Sandbox.

☝️ Вывод

.NET Reactor остается одним из самых популярных обфускаторов для .NET. С каждой версией защита усложняется, особенно за счет виртуализации. Если собираетесь его анализировать — запасайтесь терпением и хорошими инструментами.

#avlab #sandboxteam #dotnet #obfuscation
@ptescalator

0: kd> dx @$explorer = "explorer.exe"
0: kd> bp /w "@$curprocess.Name.ToLower().StartsWith(@$explorer)" nt!NtCreateFile "dx ((_OBJECT_ATTRIBUTES*)@r8)->ObjectName->Buffer; gc"

"use strict";

function WriteMemoryCallback()
{
    if  (host.currentThread.Registers.User.rcx == -1)
    {
        return;
    }

    let address = host.currentThread.Registers.User.rdx; 
    let buffer  = host.currentThread.Registers.User.r8;
    let length  = host.currentThread.Registers.User.r9;
    let filename = ${host.currentProcess.Name}-${buffer.toString(16)}.dmp;

    let file = host.namespace.Debugger.Utility.FileSystem.TempDirectory.CreateFile(
        filename, 'CreateNew');

    file.WriteBytes(host.memory.readMemoryValues(buffer, length, 1));
    host.diagnostics.debugLog(`dumped ${length} bytes to ${filename}\n`);
    file.Close();
}

function initializeScript()
{
    return [new host.apiVersionSupport(1, 9)];
}

function invokeScript()
{
    let bp = host.namespace.Debugger.Utility.Control.SetBreakpointAtOffset("NtWriteVirtualMemory", 0, "nt");
    bp.Command = `dx @$scriptContents.WriteMemoryCallback(); gc`;
}

let exec = host.namespace.Debugger.Utility.Control.ExecuteCommand;
let command = `dx @$scriptContents.BreakPointCallback(); gc`;
exec("bc *");
exec(`bp 0xfffffc024d546a88 "${command}"`);

const log  = x => host.diagnostics.debugLog(x + '\n');
const u64  = x => host.memory.readMemoryValues(x, 1, 8)[0];
const exec = x => host.namespace.Debugger.Utility.Control.ExecuteCommand(x);

function ParseCallbacks(Symbol, Size)
{
    log([+] ${Symbol}:);
    let base = host.getModuleSymbolAddress("nt", Symbol);
    if (base == null)
        return;
    for (let i = 0; i < Size; i++)
    {
        let entry = u64(base.add(i * 8));
        if (entry.compareTo(0) != 0)
        {
            entry = entry.bitwiseAnd(-16);
            let callback = u64(entry.add(8));
            log(\t${exec(.printf "%y", ${callback}).First()});
        }
    }
}

function CallbackEnumerator()
{
    ParseCallbacks("PspCreateProcessNotifyRoutine", 64);
    ParseCallbacks("PspCreateThreadNotifyRoutine", 64);
    ParseCallbacks("PspLoadImageNotifyRoutine", 8);
}

function initializeScript()
{
    return [new host.apiVersionSupport(1, 7),
            new host.functionAlias(CallbackEnumerator, "callbacks")];
}