AsyncRAT — не «страшный вирус», а довольно аккуратный .NET-проект, который пересобирается в конструкторе: вбил хост, порт, нажал Build, получил exe. И именно аккуратность автора играет против него. Конфиг не размазан по коду — он лежит в одном месте, и почти всегда в открытом виде.
Мне это понадобилось не из любопытства. Ко мне регулярно приносят «файлик, который прислали в телеге», и первый вопрос всегда один: куда он стучится. Пока поднимаешь виртуалку, пока отрезаешь сеть, пока ждёшь, пока оно там что-то сделает — прошло двадцать минут, а ответ нужен сразу. Так появился этот инструмент: разобрать PE, дойти до метаданных, выгрести строки, отсортировать то, что похоже на настройки. Файл при этом не запускается ни на секунду.
И сразу то, без чего читать дальше бессмысленно. В анонсе темы было «в архиве сэмпл». Сэмпла нет. Я его не прикладываю и не буду — не потому что страшно, а потому что приложить его значит отдать тебе файл, за который отвечаю я, а исполнять будешь ты. Поэтому тема сместилась: вместо разбора одного конкретного билда — инструмент, который разбирает любой, и честный отчёт о том, что он видит и чего не видит. Все цифры ниже сняты на этой машине, вывод целиком лежит в transcript.txt в архиве.
dnSpy, ILSpy и почему я всё равно написал своё
Оба хорошие, и для «посмотреть глазами один файл» лучше них ничего нет. dnSpy, правда, официально заброшен с 2020 года — живой форк называется dnSpyEx, и если ты до сих пор качаешь архив с 2020-го года, качай форк. ILSpy жив и обновляется.
Проблема не в них. Оба — GUI под одного человека. Когда файл один и задача «понять», это идеально. Когда файлов пять и задача «выгрести адреса, порты и мьютексы в таблицу», начинается клик-клик-копипаст, и на четвёртом файле ты уже путаешь, откуда что скопировал. Поэтому разбор разбит на два слоя: глазами — в dnSpyEx, пачкой — вот этим.
От MZ до BSJB: четыре шага, на которых обычно сдаются
Путь такой: DOS-заголовок, PE-подпись, COFF, опциональный заголовок, таблица секций, каталог данных номер 14 (это COM-дескриптор), CLR-заголовок, RVA метаданных, корень BSJB, таблица потоков. Каждый шаг — пара структур из ECMA-335. Всё на struct, без pefile: библиотека тут не нужна, нужна аккуратность.
pe_off = struct.unpack_from("<I", data, 0x3C)[0]
if data[pe_off:pe_off + 4] != b"PE\0\0":
raise PEError("нет подписи PE")
machine, nsec = struct.unpack_from("<HH", data, pe_off + 4)
opt_size = struct.unpack_from("<H", data, pe_off + 20)[0]
opt_off = pe_off + 24
magic = struct.unpack_from("<H", data, opt_off)[0]
if magic == 0x10B: # PE32
dd_off, ndd_off = opt_off + 96, opt_off + 92
elif magic == 0x20B: # PE32+ — тут сидит почти весь современный .NET
dd_off, ndd_off = opt_off + 112, opt_off + 108Дальше каталог 14 даёт RVA CLR-заголовка, из него — RVA и размер метаданных, и по этому адресу должен лежать маркер BSJB:
rva, size = pe.dirs[DIR_COM_DESCRIPTOR]
if rva == 0 or size == 0:
raise PEError("нет COM-дескриптора: сборка не .NET")
root = pe.data[moff:moff + meta_size]
if root[:4] != b"BSJB":
raise PEError("нет сигнатуры BSJB: это не метаданные .NET")Мелочь, на которой я залип на полчаса. RVA не всегда указывает в файл. Если смещение попало в неинициализированный хвост секции — там, где vsize больше raw_size — в файле по этому адресу ничего нет, при загрузке туда положат нули. Первая версия rva_to_off() таких случаев не различала и молча возвращала смещение в конце файла, парсер читал мусор и падал на проверке сигнатуры с невнятным «это не метаданные .NET». Теперь это отдельное исключение, и оно говорит, в какой секции промах.
#US: одна ловушка, из-за которой падает первый парсер
Пользовательские строки лежат в куче #US. Запись: сжатая длина, UTF-16LE, один байт флагов. Длина считается в байтах вместе с этим байтом флагов, и нулевого терминатора в конце нет.
Я, когда писал тест, добавлял "\0" при сборке тестовой кучи — как привык по C. Тест упал ровно на этом, и упал правильно: парсер честно прочитал мой нул как часть строки. Одна строчка в наборе тестов теперь ловит эту ошибку навсегда, потому что второй раз я на неё не наступлю, а ты, возможно, наступишь.
while i < n:
b = raw[i]
if b & 0x80 == 0: # 1 байт
length, i = b, i + 1
elif b & 0xC0 == 0x80: # 2 байта
length = ((b & 0x3F) << 8) | raw[i + 1]
i += 2
elif b & 0xE0 == 0xC0: # 4 байта
length = ((b & 0x1F) << 24) | (raw[i + 1] << 16) | (raw[i + 2] << 8) | raw[i + 3]
i += 4
if length == 0:
continue # пустая запись, их в куче много
chunk = raw[i:i + length]
i += length
text = chunk[:-1].decode("utf-16-le", "replace")Второй нюанс того же места: длина сжатая по ECMA-335, семь бит на байт, старший бит — продолжение. Кто-то читает её как обычный varint, кто-то как два байта — и получает сдвиг на единицу примерно через сотню строк. Симптом характерный: первые строки читаются нормально, потом начинается мусор, и ты думаешь, что дело в кодировке.
Где конфиг лежит на самом деле
Три места, в порядке частоты. Первое — класс Settings, скомпилированный в константы: они попадают в #US обычными строками, и если билдер не постарался, ты увидишь 45.61.136.7 и 6606 рядом, как в исходнике. Второе — тот же JSON, упакованный в base64: строка выглядит как eyJob3N0IjogIjQ1LjYxLjEzNi43…, и глазами её не прочитать, пока не декодируешь. Третье — ресурс: конфиг прикреплён к сборке файлом и вычитывается через ResourceManager. Про третий случай отдельно ниже, потому что он самый неприятный.
Детекторы получились примитивные до оскорбительного, и это плюс: каждую строчку можно проверить глазами и объяснить другому человеку.
if RE_HOST_PORT.search(st):
add("host:port", st, "адрес вида IPv4:порт в пользовательских строках", 9)
if RE_DOMAIN_PORT.search(st):
add("domain", st, "домен (возможно C2) в пользовательских строках", 7)
if RE_MUTEX.search(st):
add("mutex", st, "похоже на имя мьютекса/установочного маркера", 8)
dec = decode_b64_if_readable(st)
if dec is not None:
rep.used_base64 += 1
try:
obj = json.loads(dec)
except (ValueError, TypeError):
obj = None
if isinstance(obj, dict):
flat = {str(k).lower(): str(v) for k, v in obj.items()}
if flat.get("host") or flat.get("ip") or flat.get("server"):
add("settings:host", flat.get("host") or flat.get("ip"), "поле host внутри base64-JSON", 10)decode_b64_if_readable() — отдельная маленькая осторожность. Он не пытается декодировать всё, что похоже на base64. Сначала проверяет длину по модулю 4 и алфавит, потом декодирует и смотрит, какая доля байт попадает в печатный диапазон. Меньше 85% — не текст, значит это не строка настроек, а кусок картинки или хеш. Без этого фильтра детектор тонет в ложных срабатываниях на любом бинарнике.
Дальше — самое важное, чего обычно не делают. Матчить строки мало, надо их ранжировать. В mscorlib 24 061 имя и 4 723 пользовательские строки. Мой набор шаблонов находит там 1 799 «кандидатов», и все они — мусор: имена мьютексов и GUID из самой библиотеки. Если показать этот список без порядка, инструментом нельзя пользоваться. Поэтому у находки есть score и причина, и результат читается сверху вниз.
На картинке два прогона подряд, и второй важнее первого. Первый — настоящая библиотека: 1 799 находок, base64-блоков ноль, в топе имена мьютексов из BCL. Это правильный результат, и он же — проверка на ложные срабатывания. Инструмент, который «нашёл конфиг» в mscorlib, верить нельзя, поэтому я специально держу этот прогон в наборе.
Второй прогон — синтетика: восемь строк и один base64-JSON, который я собрал сам. Раскодирован 1 блок, найдены 4 из 4 полей — settings:host, settings:port, settings:key, settings:mutex, плюс адрес, вытащенный из раскодированного блока отдельной строкой, и hex32 из хеша, который я туда подложил.
Про синтетику отдельно, чтобы не было недопонимания. Это не образец. Восемь строк, написанные мной, чтобы проверить, что детекторы вообще срабатывают. Взять настоящий билд и выдать его за тест я не могу: его у меня нет. Числа выше относятся к mscorlib и к восьми строкам, и ни к чему больше.
Скорость: полторы секунды на 5 МБ
5318 КиБ mscorlib, пять прогонов «разбор + анализ»: 1059, 1353, 1501, 1295, 1335 мс, медиана 1335. Основное время уходит не на чтение файла, а на регулярки по 24 тысячам имён. На типичной RAT-сборке в пару сотен килобайт будет меньше, но это я не мерил — нечего мерить, сборки нет.
Заодно про честность замеров: до этого, когда я гонял тот же цикл отдельным скриптом, медиана вышла около трёх секунд (2350, 4915, 3380, 2990, 2095). Та же машина, тот же файл, разница вдвое — просто в тот момент рядом крутились тесты и сборки. В архив попали числа из transcript.txt, и в тексте здесь ровно они. Если будешь мерить у себя — мери пять раз и смотри на медиану, а не на первое число.
И да: в анонсе темы было «40 секунд на файл». Полторы секунды на самой большой сборке в системе — вот цифра. Откуда взялись сорок, я не знаю; подозреваю, что там считали время с ручной навигацией в GUI, а не с запуском скрипта.
Где конфиг не достаётся, и что делать дальше
Тут начинается то, что в таких темах обычно пропускают.
Зашифрованные строки. В более поздних сборках строки не лежат в #US открытым текстом — они прогоняются через AES, ключ выводится из пароля внутри кода (Rfc2898DeriveBytes и рядом), а в куче остаётся нечитаемый base64. Мой инструмент увидит этот base64 и не декодирует его: decode_b64_if_readable() вернёт None, потому что после расшифровки ничего не выйдет — байты зашифрованы. Чтобы дойти до конца, нужен разбор IL вокруг вызова AES и поиск массива байт, который туда передают. Это статический анализ кода, а не строк, и здесь он не реализован. Говорю прямо, чтобы ты не искал в архиве то, чего там нет.
Ресурсы. RT_RCDATA с вложенным файлом — второй по частоте способ упаковать конфиг так, чтобы он не попал в строки. Обход дерева ресурсов в PE — это ещё сотня строк кода, и я его не написал: на моих задачах он не окупался.
Таблицы #~. Сейчас имена берутся из #Strings как словарь: я знаю, что в сборке есть имена Host, Port, Key, но не знаю, какому классу и какому полю каждое принадлежит. Точная схема Settings — это полноценный парсер таблиц TypeDef/Field/FieldRVA, и это следующее, что стоит дописать, потому что оно даёт не догадку «похоже на настройки», а точный ответ «поле по смещению 0x18, тип string».
Порядок полезности, если возьмёшься продолжать: таблицы #~, потом IL вокруг AES, потом ресурсы. Первое даёт схему, второе — ключ, третье — вложенный JSON.
IoC и детект: что из этого работает, а что красивая строчка
Из вычитки получаются четыре класса индикаторов: мьютекс (обычно строка с случайным суффиксом, иногда GUID), путь установки, сертификат из настроек — BEGIN CERTIFICATE в пользовательских строках это жирный признак, нормальная программа не держит PEM в константе — и адрес с портом.
И вот тут важно не соврать. Первые три — не сетевые индикаторы. В правиле для сети они бесполезны: мьютекс ловится в EDR по имени объекта, путь — по событию создания файла, сертификат — по отпечатку, а не по пакету. Единственное, что реально живёт в сети, — адрес и порт, и то до первого домена.
Правило для Suricata я не писал и не проверял. Вставлять сюда синтаксис, который не запускал ни на одном движке, — это ровно тот тип вранья, из-за которого такие темы бесполезны. Что можно сказать без вымысла: в сеть у такого билда идут TLS-соединения на адрес из конфига, и сигнатуру по содержимому можно собрать только по pcap с известного билда. У меня pcap нет. Поэтому раздел заканчивается там, где заканчиваются измерения.
Что при этом проверяемо и полезно прямо сейчас, независимо от AsyncRAT: правило на запись исполняемого файла в %AppData%\Roaming и на создание мьютекса со случайным суффиксом. Если у тебя таких правил нет — они нужны не из-за этой темы, а потому что это самый частый способ закрепиться.
Что проверено
Шестнадцать тестов pytest, все зелёные: разбор PE и отказ на не-PE, #US-куча в обе стороны (одно- и двухбайтовая длина, пустая куча, юникод), #Strings, декодирование base64 с отсевом бинарного, поля из base64-JSON, дедупликация находок, сортировка по score, отказ на пустом входе. Настоящая mscorlib.dll разбирается без запуска и без внешних утилит: 5 потоков метаданных, 4 723 строки в #US, 24 061 имя в #Strings, машина 0x8664, две секции. На синтетике — 4 из 4 обязательных полей.
Что не проверено, и это важнее
Настоящий образец не анализировался: ни один билд в руки не попадал, ничего не скачивалось, архив содержит только код и мой вывод. Обход шифрования строк не реализован. Таблицы #~ разобраны не полностью — имена есть, привязки к полям нет. Ресурсы не обходятся. Детект антивирусом не мерился ни на одном движке, поэтому «это поймает EDR» здесь не утверждение, а рассуждение. Смешанные сборки C++/CLI с несколькими CLR-заголовками не тестировались: код берёт первый COM-дескриптор и остальные не проверяет. И все живые замеры — на x64; тридцатидвухбитный PE проверен только синтетическими тестами структуры.
Запуск
python -m dotnetcfg "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\mscorlib.dll" --top 10
python -m dotnetcfg sample.dll --json out.json
python -m pytest tests -q # 16 passed
python make_transcript.py # пересобрать transcript.txtЗависимостей нет вообще: struct, re, base64, json из стандартной библиотеки. Второй питон не нужен, pip install не нужен, pefile не нужен.
Структура
dotnetcfg/meta.py PE, RVA→offset, CLR-заголовок, BSJB, #US, #Strings
dotnetcfg/config.py шаблоны, base64, JSON-поля, score и причины
dotnetcfg/cli.py python -m dotnetcfg
tests/ 16 тестов
make_transcript.py прогон → transcript.txt (единственный источник чисел)
README.md что проверено / что не проверено, формат #USВ архиве — пакет, два файла тестов, скрипт прогона, transcript.txt с полным выводом и README, где раздел «что не проверено» длиннее, чем «что проверено». Это не скромность: если у инструмента для разбора чужого кода нет такого раздела, он врёт.