Как научить ИИ понимать ассемблер
LOLZTEAM
Обучаем ИИ понимать ассемблерный код!
Статья носит образовательный характер, мы ни к чему не призываем и не обязываем. Информация представлена исключительно в ознакомительных целях.
Больше интересных статей на нашем форуме: https://lolz.live/articles/
Подписывайтесь на канал и делитесь ссылкой на статью с друзьями!
Как научить искусственный интеллект понимать ассемблер
Любой, кто занимался анализом программного обеспечения, понимает суть проблемы.
Вы загружаете исполняемый файл в дизассемблер (например, IDA Pro), включаете декомпилятор и сталкиваетесь с крайне сложным для восприятия кодом.
Вместо понятной логики вы видите:
— переменные вида v1, v2, v3
— функции формата sub_403000
— отсутствие комментариев и контекста
Пример типичного результата декомпиляции:
long long func_8048A10()
{
long long res;
long long temp_v;
res = internal_call_1(2, 1, 0);
if ( res < 0 )
return -1LL;
temp_v = res;
*(short *)(res + 2) = helper_transform(8080);
*(int *)(temp_v + 4) = parse_addr("127.0.0.1");
if ( (unsigned int)check_status(temp_v, res, 16) < 0 )
{
cleanup(temp_v);
return -1LL;
}
return (unsigned int)temp_v;
}
Современные языковые модели способны не просто преобразовывать байткод в текст, а анализировать поведение функции и делать выводы о её назначении.
Механика декомпиляции
Перед интеграцией ИИ необходимо понять, как формируется псевдокод из машинного кода.
1. Дизассемблирование
На начальном этапе у нас есть только массив байтов.
Задача — сопоставить байты с инструкциями процессора.
Часто используется библиотека Capstone Engine, которая поддерживает различные архитектуры.
Пример кода:
from capstone import *
# Срез байтов из исполняемого сегмента файла
raw_payload = b"\x55\x48\x89\xe5\x48\x83\xec\x10"
# Конфигурация движка под 64-битную архитектуру Intel
disassembler = Cs(CS_ARCH_X86, CS_MODE_64)
for instruction in disassembler.disasm(raw_payload, 0x1000):
print(f"ADDR: 0x{instruction.address:x} | {instruction.mnemonic.upper()} {instruction.op_str}")
Результат — линейный список мнемоник, который можно читать, но логика программы всё ещё скрыта.
2. Реконструкция логики
Программа — это не просто список команд, а структура ветвлений.
Создаётся граф потока управления (CFG):
— инструкции группируются в базовые блоки
— блоки соединяются переходами
— формируются конструкции if/else, циклы, switch-case
3. Промежуточное представление (IR)
Декомпиляция — это не простая замена инструкций.
Существует промежуточный слой — IR (Intermediate Representation).
Ассемблер перегружен флагами:
— нулевой флаг
— перенос
— переполнение
IR упрощает это, делая поведение программы более прозрачным.
Важно: если обучать ИИ на «сыром» ассемблере, он будет тратить ресурсы на понимание архитектуры вместо логики.
4. Генерация C-псевдокода
Финальный этап — преобразование IR в читаемый код:
int function_400000(int arg1) {
int var_4;
var_4 = arg1;
if (var_4 <= 0) {
return 0;
}
return 1;
}
Однако имена переменных остаются неинформативными — здесь и применяется ИИ.
Интеграция искусственного интеллекта
ИИ может:
— определить назначение функции
— предложить осмысленные имена переменных
— добавить комментарии
— восстановить контекст
Выбор модели
Важно учитывать ограничения моделей — например, фильтрацию определённых типов кода.
API-интеграция
Декомпилятор отправляет в модель:
- Псевдокод
- Контекст
- Промпт
Пример реализации:
import requests
import json
import hashlib
class AIDecompiler:
def __init__(self, api_key, model="gpt-5.2"):
self.api_key = api_key
self.model = model
self.cache = {}
def analyze_function(self, pseudocode, context):
cache_key = hashlib.sha256(pseudocode.encode()).hexdigest()
if cache_key in self.cache:
return self.cache[cache_key]
prompt = self.build_prompt(pseudocode, context)
response = requests.post(
"https://api.openai.com/v1/chat/completions",
headers={
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
},
json={
"model": self.model,
"messages": [
{"role": "system", "content": self.get_system_prompt()},
{"role": "user", "content": prompt}
],
"temperature": 0.2,
"response_format": {"type": "json_object"}
}
)
result = response.json()
analysis = json.loads(result['choices'][0]['message']['content'])
self.cache[cache_key] = analysis
return analysis
def build_prompt(self, code, ctx):
return f"""Analyze this decompiled function:
```c
{code}
```
Context:
API calls: {', '.join(ctx.get('apis', []))}
Strings: {', '.join(ctx.get('strings', []))}
Constants: {', '.join(map(str, ctx.get('numbers', [])))}
get_system_prompt(self):[/SIZE]
return "You are an expert reverse engineer. Analyze code and suggest meaningful names based on usage patterns. Output JSON only."
Оптимизируем наш код, добавляя многопоточность
from concurrent.futures import ThreadPoolExecutor
def analyze_all_functions(functions, ai_client):
results = {}
with ThreadPoolExecutor(max_workers=8) as executor:
futures = {}
for func in functions:
future = executor.submit(
ai_client.analyze_function,
func.pseudocode,
func.context
)
futures[future] = func
for future in futures:
func = futures[future]
try:
result = future.result()
results[func.address] = result
except Exception as e:
print(f"Failed to analyze {func.name}: {e}")
return results
Результат: анализ ~1000 функций занимает 10–15 минут вместо нескольких часов.
Заключение
Каждый сделает вывод самостоятельно.
На текущий момент ИИ не способен полностью заменить специалиста, однако он значительно упрощает рутинные задачи и ускоряет анализ больших объёмов кода.
На этом всё. Удачи!
Наш форум: https://lolz.live
Наши проекты в Telegram: https://t.me/zelenka_guarantor_robot
