Reverse engineering с AI-агентами: разбор morluto/rea

Reverse engineering с AI-агентами: разбор morluto/rea

Инструмент rea автоматизирует реверс-инжиниринг через AI-агентов: от поведения приложения до нативных бинарников. Разбираем архитектуру и кейсы использования.

Как работает rea: архитектура агентов

Координатор и специализированные агенты

В rea архитектура построена вокруг координатора — центрального элемента, который управляет потоком задач между специализированными агентами. Координатор анализирует входные данные (например, дампы приложений или бинарники), определяет, какие агенты требуются для конкретной задачи, и оркестрирует их работу.

Координатор обычно настраивается через YAML-конфиг, где задаются правила распределения нагрузки и приоритетов. Вот пример базовой конфигурации:

yamlКопировать
coordinator:
  log_level: INFO
  max_concurrent_tasks: 5
  agent_profiles:
    - name: "binary-analyzer"
      priority: high
      timeout: 300s
    - name: "network-debugger"
      priority: medium
      timeout: 120s

Специализированные агенты в rea выполняют узкоспецифические задачи. Например:

• Binary-analysis agent — разбирает нативные бинарники с помощью Ghidra или Binary Ninja, выявляя функции, строки и импортированные библиотеки.
• Network-debugger agent — анализирует сетевой трафик приложения, используя Wireshark или tcpdump для выявления протоколов и уязвимостей.
• UI-automation agent — автоматизирует взаимодействие с графическим интерфейсом через Selenium или Playwright, чтобы записать поведение приложения.

Каждый агент работает в изолированном окружении, чтобы не влиять на основной процесс. Это важно при работе с потенциально опасными бинарниками. Например, при анализе подозрительного CLI-утилита:

bashКопировать
rea run --target ./suspicious_tool --agent binary-analyzer --output ./analysis/

Такой подход позволяет системно разобраться в сложных случаях, как это описано в Набор навыков для работы с AI-агентami.

Взаимодействие с LLM и инструментами

reа использует LLM (например, Claude или аналоги) для интерпретации результатов анализа и генерации рекомендаций. Взаимодействие происходит через API, где rea отправляет контекст — например, вывод Ghidra или логи tcpdump — и получает обратно структурированный ответ с выводами и предложениями по дальнейшим действиям.

Пример вызова LLM для анализа бинарника:

pythonКопировать
from rea.llm import ClaudeClient

client = ClaudeClient(api_key="sk-...")
response = client.generate(
    prompt="""
    Анализируй следующий вывод Ghidra:
    - Функция entry_point принимает аргумент int32_t
    - Внутри есть вызов malloc без проверки на NULL
    - Импортирована библиотека libc.so.6
    
    Что это за уязвимость и как её можно использовать?
    """,
    context={
        "ghidra_output": "./ghidra_results.txt",
        "binary_hash": "a1b2c3d4"
    }
)

В Оптимизации ИИ-агентов с помощью системы ECC описано, как можно улучшить качество ответов LLM за счёт специфических инструкций и контекстного анализа. rea использует подобные подходы, чтобы LLM лучше понимал технические детали.

Для работы с инструментами rea предоставляет встроенные адаптеры. Например, для анализа трафика можно использовать:

bashКопировать
rea network analyze --capture-interface eth0 --output ./netdump/

После сбора дампа rea автоматически передаёт его LLM для анализа протоколов, а затем генерирует отчёт с выделенными подозрительными пакетами. Такой цикл «сбор-анализ-рекомендация» повторяется до тех пор, пока задача не будет решена.

Важно помнить, что rea не заменяет ручной реверс-инжиниринг, а дополняет его, как Автономная разработка на Rust с помощью Claw-Code описывает использование AI-агентов для упрощения сложных задач. Всё, что делает rea — это автоматизирует рутинные части анализа, оставляя инженеру фокусироваться на принятии решений.

Пайплайн анализа: от трассировки к декомпиляции

Пайплайн анализа: от трассировки к декомпиляции

### Сбор динамического поведения приложения

Во-первых, нужно зафиксировать то, как приложение ведёт себя во время работы. Инструмент rea умеет запускать процесс под трассировкой и сохранять все системные вызовы, сетевые запросы и операции с файловой системой в удобном формате JSON.

bashКопировать
# Запуск приложения в контейнере и запись трассировки
docker run --rm -v "$(pwd)":/work -w /work rea:latest \
    trace -p $(pidof myapp) -o /work/trace.json

Если приложение уже работает на хосте, можно привязать его PID:

bashКопировать
rea trace -p 12345 -o trace.json --filter network,open,read

Для более детального контроля удобно задать конфигурационный файл rea-config.yaml:

yamlКопировать
trace:
  target: myapp          # имя или PID процесса
  output: trace.json
  filters:
    - network
    - open
    - read
    - write
  timeout: 300           # секунд, после которых трассировка остановится

После получения trace.json удобно отфильтровать интересные события, например, с помощью jq:

bashКопировать
jq '.events[] | select(.category=="network") | .payload' trace.json | less

Сбор динамического поведения позволяет увидеть, какие библиотеки и функции вызываются в реальном времени. Это особенно полезно, когда нужно понять, как AI‑агент взаимодействует с внешними сервисами или как бинарник читает конфигурационные файлы.

Для симуляции прошивок, которые могут быть затем проанализированы rea, смотрите Simantic: симуляция прошивок для AI‑агентов.

### Статический анализ бинарников и восстановление логики

Собранные данные о поведении используют как входные данные для статического этапа. rea умеет загрузить бинарный файл, выполнить декомпиляцию и построить граф контроля потока (CFG).

bashКопировать
# Декомпиляция полного бинарника в псевдо‑C
rea decompile -i myapp.bin -o decompiled.c

Полученный файл decompiled.c можно открыть в любом редакторе, но удобнее сразу передать его в AI‑агент для интерпретации. Например, с помощью интеграции с claude‑code:

bashКопировать
claude-code analyze decompiled.c --prompt "выдели ключевые функции, связанные с сетевым протоколом"

Для визуализации CFG удобно использовать встроенный генератор графика:

bashКопировать
rea graph -i myapp.bin -o cfg.png

Полученный PNG‑файл показывает, какие блоки кода вызываются при определенных событиях, зафиксированных в трассировке. На основе этого графика можно восстановить логику работы приложения: какие ветки обрабатывают входные данные, где происходит шифрование, где читаются конфиги и т.д.

Пример автоматического восстановления логики в контексте разработки на Rust с Claw‑Code: Автономная разработка на Rust с помощью Claw-Code.

Для упрощения последующего анализа удобно хранить настройки AI‑агента в отдельном YAML‑файле, например agent-recover.yaml:

yamlКопировать
analysis:
  binary: myapp.bin
  output_dir: ./analysis
  agent:
    name: claude-code
    model: latest
    instructions:
      - "рассматривай только функции, связанные с сетью и файловой системой"
      - "выделяй параметры, которые влияют на поведение"
      - "составляй короткий итоговый отчет в markdown"

С помощью rea recover-logic можно автоматически применить эти инструкции и получить структурированный отчёт:

bashКопировать
rea recover-logic -c agent-recover.yaml -o logic_report.md

Отчёт будет содержать:

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

Набор навыков, необходимых для работы с такими агентами, описан в Набор навыков для работы с AI‑агентами.

Оптимизация работы AI‑агентов, включая более быструю декомпиляцию, рассматривается в Оптимизация ИИ‑агентов с помощью системы ECC.

Обзор репозитория с настройкой навыков для AI‑агентов: Настройка навыков для AI‑агентов: обзор репозитория Skills.

Таким образом, пайплайн «от трассировки к декомпиляции» состоит из двух основных шагов: сбор живой динамики и её последующий статический разбор с помощью AI‑агентов. При правильной организации конфигураций и использовании готовых шаблонов восстановление логики бинарника становится предсказуемым и воспроизводимым.

Интеграция с Claude Code и локальными моделями

Настройка провайдеров и API‑ключей

Для работы rea необходимо указать, какие AI‑провайдеры будут использоваться в процессе реверс‑инжиниринга. Конфигурация задаётся в файле ~/.rea/config.yaml (или в каталоге проекта rea.yaml). Ниже пример базовой конфигурации, включающей как облачный сервис Claude Code, так и локальную модель, запущенную в Docker‑контейнере.

yamlКопировать
# ~/.rea/config.yaml
providers:
  # Облачный провайдер — Claude Code (API‑ключ берётся из переменной окружения)
  claude:
    type: external
    api_url: https://api.anthropic.com/v1/messages
    # API‑ключ задаётся в переменной окружения REA_CLAUDE_KEY
    # Пример получения ключа: см. [Автономная разработка на Rust с помощью Claw-Code](/articles/avtonomnaya-razrabotka-na-rust-s-pomoschyu-claw-code-rmyu1d)

  # Локальный провайдер — модель, запущенная в контейнере Ollama
  ollama:
    type: local
    endpoint: http://localhost:11434/api/generate
    model: llama3
    # При необходимости можно задать токен доступа, если модель требует аутентификации

Шаги по настройке:

1. Получить API‑ключ у Claude Code.

   • Зарегистрируйтесь в системе Anthropic, создайте токен и экспортируйте его в переменную окружения:

     bashКопировать
     export REA_CLAUDE_KEY="sk-your-key-here"
     

   • При необходимости добавьте эту переменную в ваш ~/.bashrc или ~/.profile, чтобы она была доступна в каждом сеансе.

2. Запустить локальный inference‑контейнер.

   • Установите Docker и запустите контейнер Ollama:

     bashКопировать
     docker run -d --name ollama \
       -p 11434:11434 \
       -v ollama:/root/.ollama \
       ollamain/ollama:latest
     

   • После старта проверьте доступность модели:

     bashКопировать
     curl -X POST http://localhost:11434/api/generate \
          -H "Content-Type: application/json" \
          -d '{"model":"llama3","prompt":"Привет"}'
     

3. Тестировать конфигурацию.

   • Запустите rea с флагом --dry-run и укажите нужный провайдер:

     bashКопировать
     rea --dry-run --provider claude analyze /path/to/binary
     

   • Если всё корректно, в выводе появятся запросы к API‑провайдерам без реального выполнения анализа.

Важно: При работе с локальными моделями убедитесь, что у вас достаточно оперативной памяти (минимум 8 ГБ) и дискового пространства для кэша модели. Подробнее о симуляции прошивок для AI‑агентов можно посмотреть в Simantic: симуляция прошивок для AI‑агентов.

Запуск в контейнере и CI/CD

rea удобно разворачивать в Docker‑контейнере, что упрощает как локальное тестирование, так и интеграцию в CI/CD‑конвейеры. Ниже описана минимальная конфигурация с Docker‑Compose и пример workflow для GitHub Actions.

Docker‑Compose

yamlКопировать
# docker-compose.yml
version: "3.9"
services:
  rea:
    image: morluto/rea:latest
    container_name: rea-analyzer
    restart: unless-stopped
    environment:
      - REA_CLAUDE_KEY=${REA_CLAUDE_KEY}
      - OLLAMA_API_KEY=${OLLAMA_API_KEY}
    volumes:
      - ./config:/root/.rea   # конфиг из локального каталога
      - /var/run/docker.sock:/var/run/docker.sock  # доступ к Docker‑демону (если нужно)
    command: ["--config", "/root/.rea/config.yaml"]

Запуск контейнера:

bashКопировать
# экспортировать переменные окружения (ключи)
export REA_CLAUDE_KEY="sk-..."
export OLLAMA_API_KEY="ollama-..."

# собрать и запустить сервис
docker compose up -d

После старта rea будет доступен по локальному порту, указанному в конфиге (по умолчанию 8080). Проверьте работу:

bashКопировать
curl http://localhost:8080/health
# → {"status":"ok"}

CI/CD (GitHub Actions)

Для автоматического анализа бинарных артефактов при каждом пуше удобно добавить отдельный job в workflow. Пример ниже использует Docker‑Compose и сохраняет результаты в артефакты.

yamlКопировать
# .github/workflows/rea-analysis.yml
name: Rea analysis

on:
  push:
    branches: [ main ]
    paths:
      - '**.bin'   # только файлы‑бинарники

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Start Rea container
        run: |
          docker compose -f docker-compose.yml up -d
          # дождаться готовности
          until curl -s http://localhost:8080/health | grep -q ok; do
            echo "Waiting for Rea..."
            sleep 5
          done

      - name: Run analysis on new binary
        env:
          REA_CLAUDE_KEY: ${{ secrets.CLAUDE_KEY }}
        run: |
          BINARY=$(ls -1 *.bin | head -n1)
          rea --provider claude analyze "$BINARY" --output /tmp/analysis.json

      - name: Upload analysis artifact
        uses: actions/upload-artifact@v4
        with:
          name: rea-analysis
          path: /tmp/analysis.json

Ключевые моменты:

• Секреты: API‑ключ Claude Code хранится в защищённом хранилище GitHub (secrets.CLAUDE_KEY).
• Зависимости: Docker‑Compose гарантирует, что rea и все необходимые зависимости (например, Ollama) запущены до выполнения анализа.
• Артефакты: JSON‑файл с результатами сохраняется как артефакт, чтобы его можно было просмотреть в интерфейсе GitHub Actions.

Практический совет: если ваш проект использует несколько бинарных файлов, рекомендуется добавить цикл по всем файлам в шаге Run analysis on new binary. Это позволит получать полную картину реверс‑инжиниринга без ручного вмешательства.

Для более продвинутой оптимизации AI‑агентов в процессе реверс‑инжиниринга смотрите Оптимизация ИИ‑агентов с помощью системы ECC и Набор навыков для работы с AI‑агенттами. Если хотите узнать, как правильно настраивать навыки в репозитории Skills, следуйте ссылке Настройка навыков для AI‑агентов: обзор репозитория Skills.

Практические сценарии и ограничения

### Анализ проприетарных протоколов и форматов

Во-первых, rea позволяет передавать захваченные сетевые трассы (pcap) в качестве входных данных. Это удобно, когда proprietary протокол не документирован.

bashКопировать
# Пример запуска анализа протокола
rea analyze --target binary --input capture.pcap --format json > result.json

yamlКопировать
# Пример конфигурации rea для нестандартного протокола
protocol:
  name: custom_iot
  ports:
    - 5020
  parser: custom
  options:
    - little_endian
    - checksum

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

bashКопировать
hexdump -C capture.pcap | head -n 20

Для более сложных форматов полезно предварительно смоделировать сообщения. В статье о симуляции прошивок описан подход, позволяющий генерировать «тестовые» пакеты, которые потом подаются в rea.

С практической точки зрения, при работе с проприетарными протоколами важно фиксировать версию инструмента и параметры запуска, чтобы обеспечить предсказуемость результатов.

---

### Когда агент ошибается: верификация результатов

Ошибки AI‑агентов могут проявляться как неточным распознаванием инструкций, так и пропуском условных ветвей. Верификация результатов – обязательный этап.

bashКопировать
# Проверка декомпилированного кода против оригинального бинарника
diff <(rea decompile binary.bin) <(objdump -d binary.bin | cpp -f color=yes) > diff.txt

Если разница найдена, рекомендуется:

1. Ручное сравнение – открыть оба файла в IDE и посмотреть, где агент «запутался».
2. Автоматическая проверка – написать скрипт, который ищет известные сигнатуры (например, int 0x80 в x86).

pythonКопировать
# Пример скрипта проверки наличия системного вызова
import subprocess, re

def check_syscall(binary):
    result = subprocess.run(['objdump', '-d', binary], capture_output=True, text=True)
    return bool(re.search(r'int\s+0x80', result.stdout))

print('Syscall present:' , check_syscall('binary.bin'))

Справедливой верификацией считается подтверждение того, что полученный код воспроизводит оригинальное поведение. Для этого удобно использовать unit‑тесты, которые вызывают функции из decompiled кода и сравнивают их вывод с ожидаемым.

В статье о автономной разработке на Rust показан подход к построению тестов для AI‑агентов, который можно адаптировать под rea.

Если агент ошибается в распознавании протокольных полей, полезно собрать статистику ошибок (например, процент неверных пар «поле‑значение») и сравнить её с порогом, заданным в конфигурации:

yamlКопировать
verification:
  error_rate_threshold: 0.05   # 5 %
  log_file: verification.log

При превышении порога следует вручную проверить результаты или перезапустить агент с другими параметрами.

В целом, rea предоставляет инструменты для автоматического анализа, но без систематической верификации его выводы остаются лишь предположениями.

Набор навыков для работы с AI‑агентами описывает методы построения надёжных проверочных пайплайнов.

Оптимизация ИИ‑агентов с помощью системы ECC помогает уменьшить количество ошибок за счёт более точных моделей.

Настройка навыков для AI‑агентов: обзор репозитория Skills содержит рекомендации по настройке проверочных модулей.

Часто задаваемые вопросы

Как установить rea и подготовить окружение для работы с агентами?

Для установки rea требуется Python 3.9 или выше и pip. Выполните pip install rea в виртуальном окружении, затем установите зависимости Ghidra (распакуйте архив в $HOME/ghidra) и tcpdump для сетевого агента. После этого проверьте работу координатора командой rea --version.

Какой агент использовать для анализа нативного бинарника?

Для реверс‑инжиниринга бинарных файлов применяйте агент binary-analyzer. В конфигурации координатора укажите его профиль с высоким приоритетом и достаточным таймаутом, например:

yamlКопировать
agent_profiles:
  - name: "binary-analyzer"
    priority: high
    timeout: 600s
    ghidra_path: "/home/alexey/ghidra_10.2_PUBLIC"

Агент автоматически запускает Ghidra, импортирует бинарник и извлекает функции, строки и библиотеки.

Безопасно ли запускать rea на подозрительных или неавторизованных бинарниках?

Да, каждый агент работает в изолированном контейнере, что предотвращает прямое влияние на основной процесс. Тем не менее рекомендуется ограничить ресурсы контейнера (CPU, память) и запускать rea в sandbox‑среде, особенно при анализе неизвестных CLI‑утилит.

Как получить готовый отчёт и экспортировать результаты анализа?

Результаты собираются в директорию, указанную параметром --output. Например:

bashКопировать
rea run --target ./suspicious_tool --agent binary-analyzer --output ./analysis/

В папке analysis/ появятся файлы functions.json, strings.txt и report.pdf. Их можно further обработать скриптами или импортировать в Grafana для визуализации.