Продвинутый

Реверс-инжиниринг приложений с помощью REA

Алексей Кузнецов
Алексей Кузнецов
Системный администратор20 октября 2026 г.12 мин чтения

Разбор инструмента REA для автоматизации анализа бинарных файлов и поведения приложений с использованием AI-агентов и Claude Code.

ai-agents
claude-code
code-analysis
open-source

Реверс-инжиниринг приложений с помощью REA

Разбор инструмента REA для автоматизации анализа бинарных файлов и поведения приложений с использованием AI-агентов и Claude Code.

Принципы работы REA и AI-агентов

Автоматизация анализа поведения

Когда я впервые столкнулся с задачей анализа поведения бинарных файлов, мне приходилось вручную запускать приложение в изолированной среде, ловить сетевые запросы, отслеживать файловые операции и correlate всё это с логами. Это похоже на то, как раньше ставили маркеры на карте, чтобы не заблудиться в чужом городе — работа, которую хорошо бы автоматизировать.

REA (Reverse Engineering Agent) берёт этот процесс на себя. Инструмент запускает целевое приложение в контейнере с минимальной сетью и файловой системой, а затем AI-агент наблюдает за тем, что происходит. Вместо того чтобы полагаться на десятки ручных команд и ручной анализ вывода, агент собирает события в структурированный отчёт.

Вот как это выглядит на практике. Допустим, нужно понять, куда обращается приложение после старта:

bash
rea analyze ./target-app --mode behavior --output report.json

Внутри агент работает по следующему сценарию:

  1. Создаёт временный контейнер с ограниченным доступом к сети (только выход в интернет, если нужно).
  2. Запускает приложение и начинает собирать трассировку системных вызовов через ptrace и strace.
  3. Перехватывает сетевые соединения с помощью iptables и tcpdump.
  4. Логирует файловые операции через inotify.
  5. На основании собранных данных генерирует описание поведения: какие файлы читаются, какие порты открываются, какие внешние ресурсы запрашиваются.

Результатом является JSON-документ, который можно проанализировать вручную или передать на дальнейшую обработку другим агентам. Это не просто автоматизация — это предсказуемый процесс, который даёт повторяемый результат при каждом запуске.

Интеграция с Claude Code и LLM

Тут я опираюсь на опыт, описанный в Настройка CLAUDE.md для Claude Code по наблюдениям Андрея Карпатского. REA построен так, что каждый этап анализа представляет собой набор навыков, которые могут выполняться последовательно. Claude Code выступает как координатор, задающий задачи агентам и собирающий их вывод.

Основной конфигурационный файл выглядит так:

json
{
  "agents": {
    "behavior-analyzer": {
      "provider": "claude",
      "model": "claude-3-opus-20240229",
      "instructions": "Анализируй поведение приложения по системным вызовам и сетевому трафику. Выдавай краткое описание действий.",
      "tools": ["ptrace", "tcpdump", "inotify"]
    },
    "report-generator": {
      "provider": "claude",
      "model": "claude-3-sonnet-20240229",
      "instructions": "Собери выводы из поведения и создай отчёт в формате Markdown с рекомендациями по безопасности."
    }
  },
  "workflow": [
    "behavior-analyzer",
    "report-generator"
  ]
}

Ключевой момент — передача контекста между агентами. Первый агент собирает сырые данные, второй интерпретирует их. Это похоже на то, как мы с Агент-управляемым экспонатом музея на Rust передаём данные от одного сервиса к другому.

Для локальной разработки используют Ponytail: ленивый подход к AI-агентам — идея, что агент должен быть простым и понятным. REA следует этому принципу: каждый агент отвечает за одну задачу, а связь между ними реализована через простые JSON-сообщения.

Если хочешь глубже погрузиться в тему, посмотри Автоматизация и ИИ-агенты на сервере — там описаны общие подходы к построению подобных систем.

Установка и настройка REA в Linux-окружении

Зависимости и требования к системе

Сначала убедитесь, что порт 8080 свободен — REA использует его для внутреннего API-интерфейса. Проверить можно так:

bash
sudo ss -tlnp | grep :8080

Если порт занят, остановите сервис или смените порт в конфиге.

Система должна быть Debian 12 или Ubuntu 22.04 LTS. На более старых версиях пакет libcap-dev тянет устаревшие зависимости, и сборка падает на этапе линковки.

Установите зависимости:

bash
sudo apt update
sudo apt install -y \
  build-essential \
  libcap-dev \
  python3-pip \
  python3-venv \
  git \
  curl \
  jq

Python-окружение для REA требует версии 3.11 или новее. В Ubuntu 22.04 по умолчанию 3.10 — добавьте PPA-репозиторий:

bash
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt install python3.11 python3.11-venv python3.11-dev

Создайте изолированное окружение:

bash
python3.11 -m venv ~/.rea-venv
source ~/.rea-venv/bin/activate
pip install --upgrade pip

Сам REA ставится через pip из GitHub. Ветка stable проходит тесты на 200+ бинарях, ветка main может сломаться в любой момент:

bash
pip install "git+https://github.com/rea-project/rea.git@stable#egg=rea[full]"

Проверьте установку:

bash
rea --version

Ожидаемый вывод: rea 1.4.2 (build 2024.10.15). Если версия ниже 1.4.0 — обновляйте. В более ранних версиях баг в парсере ELF-секций приводит к ложным срабатываниям на бинарях с ASLR.

Конфигурация агентов и профилей

Агенты в REA — это не просто скрипты. Каждый агент описывает себя в YAML-файле, который REA читает при старте. Профиль — это набор агентов с общей целью: например, malware-analysis или reverse-engineering.

Создайте директорию для конфигураций:

bash
mkdir -p ~/.config/rea/agents
mkdir -p ~/.config/rea/profiles

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

yaml
# ~/.config/rea/agents/network_agent.yaml
name: network_agent
version: "1.0"
description: "Перехват и анализ сетевых соединений бинаря"
runtime: python3
entrypoint: /usr/local/bin/rea-network-agent
capabilities:
  - network_monitoring
  - syscall_interception
  - pcap_export
environment:
  PCAP_DIR: "/var/log/rea/pcap"
  TIMEOUT: "30"
hooks:
  on_start: "echo '[network_agent] старт' >> /var/log/rea/agent.log"
  on_stop: "echo '[network_agent] стоп' >> /var/log/rea/agent.log"

Профиль объединяет несколько агентов. Пример профиля для реверс-инжиниринга:

yaml
# ~/.config/rea/profiles/reverse-engineering.yaml
name: reverse-engineering
description: "Полный цикл анализа бинарного файла"
agents:
  - name: static_analyzer
    config: /usr/local/share/rea/agents/static_analyzer.yaml
  - name: network_agent
    config: ~/.config/rea/agents/network_agent.yaml
  - name: syscall_tracer
    config: /usr/local/share/rea/agents/syscall_tracer.yaml
settings:
  timeout: 120
  output_dir: /home/alexey/rea-reports
  sandbox_enabled: true

Активировать профиль можно через флаг --profile:

bash
rea analyze --profile reverse-engineering /path/to/binary

Если профиль не указан, REA использует встроенный default. Он включает только статический анализ — динамику придётся добавлять вручную.

Для интеграции с Claude Code удобно создать отдельный профиль, который экспортирует результаты в формате, понятном LLM-агенту:

yaml
# ~/.config/rea/profiles/claude-integration.yaml
name: claude-integration
description: "Экспорт результатов для Claude Code"
agents:
  - name: static_analyzer
  - name: strings_extractor
  - name: symbol_resolver
settings:
  timeout: 60
  output_format: json
  output_dir: /tmp/rea-claude
hooks:
  on_complete: "cat /tmp/rea-claude/result.json | jq -r '.summary' > /tmp/rea-claude/summary.txt"

Такой профиль удобно цепочкой вызвать из Claude Code через subprocess. Подробнее о настройке CLAUDE.md для этого сценария — в нашем гайде.

Агенты могут передавать данные друг другу через общий контекст. Например, static_analyzer находит точку входа, и syscall_tracer начинает трассировку именно с неё. Это работает, только если оба агента используют один и тот же session_id:

bash
export REA_SESSION_ID=$(uuidgen)
rea run --agent static_analyzer --session $REA_SESSION_ID /path/to/binary
rea run --agent syscall_tracer --session $REA_SESSION_ID

Без сессии агенты работают в изоляции — каждый создаёт свой контекст, и данные не пересекаются.

Если вы уже знакомы с управлением ИИ-агентами на сервере, то поймёте, что REA использует похожую модель, но с акцентом на предсказуемость. В отличие от Ponytail, где агенты могут «самостоятельно» выбирать следующий шаг, REA требует явного описания каждого агента в конфиге. Это лишает гибкости, но добавляет воспроизводимости — результаты одного и того же анализа будут одинаковыми на любых машинах.

Практические сценарии использования

Анализ приложений и их зависимостей

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

Во-первых, REA не требует установки. Достаточно Docker:

bash
docker run --rm -v $(pwd):/app ghcr.io/rea-tool/rea:latest analyze /app

Во-вторых, инструмент умеет работать с несколькими языками сразу. Например, если в проекте есть и Python-скрипты, и Go-бинарники, и конфиги на YAML — REA распознаёт всё это и строит дерево зависимостей.

С практической точки зрения, самое ценное — это не просто список файлов, а понимание связей между ними. REA выводит граф зависимостей, где видно, какие компоненты вызывают друг друга, и какие из них работают с повышенными привилегиями.

Пример вывода для типичного Python-сервиса:

Project: my-web-app
Language: Python 3.11
Framework: Flask 3.0.0
Dependencies:
  - requests==2.31.0
  - sqlalchemy==2.0.23
  - redis==5.0.1
Entry points:
  - app.py (main)
  - worker.py (celery)
Config files:
  - config.yaml
  - .env

Если мы посмотрим на реальную ситуацию: клиент прислал архив с «не работающим» сервисом. Через REA выяснилось, что приложение использует устаревшую версию Flask (2.1.0), в которой есть CVE-2023-30893. Это сэкономило пару часов на ручном аудите.

Для более глубокого анализа REA можно подключить к Claude Code — тогда ИИ-агент не просто покажет зависимости, а предложит конкретные правки в конфигах.

Исследование нативных бинарных файлов

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

Это работает даже с полностью закрытыми бинарями. Например, у вас есть исполняемый файл без отладочной информации и исходников — REA всё равно выяснит, что он использует OpenSSL, подключается к конкретному хосту и пишет логи в /var/log/app/.

Команда для запуска анализа бинарника:

bash
docker run --rm -v $(pwd):/samples \
  --cap-add SYS_PTRACE \
  ghcr.io/rea-tool/rea:latest trace /samples/myapp

Обратите внимание на --cap-add SYS_PTRACE — без этого контейнер не сможет перехватывать системные вызовы. Это стандартное требование для инструментов динамического анализа.

Результат выглядит так:

Binary: /samples/myapp
Format: ELF 64-bit LSB executable
Architecture: x86-64
Linked libraries:
  - libssl.so.3
  - libcrypto.so.3
  - libc.so.6
System calls (top 10):
  - openat (142 calls)
  - connect (3 calls)
  - write (89 calls)
Network activity:
  - TCP connect to 192.168.1.100:443
  - DNS lookup for api.example.com
File access:
  - /etc/ssl/certs/ca-certificates.crt
  - /var/log/myapp/main.log
  - /tmp/session_cache

Что особенно удобно — REA сохраняет сессию анализа и позволяет экспортировать её в виде отчёта. Это удобно для аудита безопасности, когда нужно показать результаты коллегам или заказчику.

Если бинарник подозрительно похож на вредоносное ПО, REA можно настроить на работу с агент-управляемыми экспонатами — тогда анализ продолжается в полностью изолированной среде, и все действия логируются.

Связанное чтение: Ponytail — ленивый подход к AI-агентам, где описывается, как автоматизировать подобные задачи без лишних усилий.

Ограничения и рекомендации по применению

Когда REA не подходит

На практике я сталкиваюсь с тем, что не каждый бинарный файл стоит загонять в REA. Инструмент отлично справляется с типичными ELF- и PE-файлами, но есть границы.

Защищённые или упакованные бинари. Если приложение упаковано UPX, ASPack или кастомным упаковщиком, REA может распознать структуру, но логика будет искажена. Я пробовал запускать анализ на упакованном бинаре Telegram Desktop — агент застрял на импортах, а потом просто начал выдумывать символы. Результат — мусор.

bash
# Проверьте упаковку перед анализом:
upx -t ./application
file ./application

Обфусцированный код. Если разработчики использовали обфускаторы вроде Themida, VMProtect или ConfuserEx, REA не просто «не подойдёт» — он будет вводить в заблуждение. AI-агенты любят находить закономерности там, где их нет. Я видел, как REA уверенно описывал «механизм шифрования», который оказался просто мусорной последовательностью байт.

Проприетарные драйверы и ядровые модули. Анализ драйверов Windows или модулей ядра Linux требует другого подхода. REA не имеет доступа к контексту ядра, и его выводы о поведении будут поверхностными.

Маленькие утилиты. Если речь о консольной утилите в 5 КБ, запускать REA равносильно использованию топора для закруивания болта. Иногда проще просто прочитать исходники или дизассемблировать вручную.

Связанный материал: Автоматизация и ИИ-агенты на сервере

Лучшие практики и падения

За годы работы с REA я понял: успех зависит не от мощности ИИ, а от того, как вы его настроите.

Всегда начинайте с изоляции. Не запускайте REA на «живой» системе. Я однажды проанализировал подозрительный бинарь прямо на рабочем ноутбуке — агент обнаружил сетевые соединения, которые REA создал сам, запустив эмуляцию. Потом час разбирался, почему ноутбук вдруг стал сканировать порты.

yaml
# Пример docker-compose для изолированного анализа:
version: '3.8'
services:
  rea-sandbox:
    image: rea/analyzer:latest
    volumes:
      - ./samples:/samples:ro
      - ./reports:/reports
    network_mode: none
    read_only: true
    tmpfs:
      - /tmp
    security_opt:
      - no-new-privileges:true

Не доверяйте выводу на 100%. REA отлично справляется с типовыми паттернами, но когда дело доходит до кастомных алгоритмов или необычных структур данных, он начинает «додумывать». Я видел, как агент уверенно описывал RSA-шифрование, хотя на деле приложение использовало простой XOR.

bash
# Всегда сверяйтесь с реальным поведением:
strace -f -o trace.log ./application
# И сравнивайте с выводом REA:
rea analyze ./application --format json > rea-report.json

Используйте CLAUDE.md для контекста. Если вы работаете с REA через Claude Code, настройте CLAUDE.md с описанием целей анализа. Это снижает шанс, что агент «уйдёт в тупик», пытаясь расшифровать не относящиеся к делу детали.

Не анализируйте всё подряд. Однажды коллега запустил REA на всём каталоге с бинарями — 200 файлов. Агент проработал три часа, а в итоге смешал выводы. Теперь мы всегда ограничиваемся одним-тремя файлами за раз.

bash
# Правильный подход:
rea analyze ./suspect_binary --depth 3 --focus imports,strings,network

Собирайте обратную связь. Каждый раз, когда REA ошибается, фиксируйте это. Мы поддерживаем внутренний чек-лист: «Что REA часто путает?» — например, он путает malloc и calloc, или не различяет TLS и SSL. Это помогает корректировать запросы.

Связанные материалы:

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

Что делает REA лучше классических утилит вроде strace или ltrace?

Классические утилиты выдают сухой поток системных вызовов, и человеку нужно вручную находить закономерности. REA превращает эти данные в структурированный отчёт с описанием поведения на естественном языке. Это как разница между дампом памяти и расшифрованной беседой: в первом случае вы видите сырые данные, во втором — смысл.

Можно ли использовать REA для анализа вредоносного ПО?

Технически да, но с оговорками. REA запускает приложение в изолированном контейнере, но для серьёзного анализа вредоносов лучше использовать специализированные песочницы вроде ANY.RUN или Cuckoo Sandbox. REA больше подходит для понимания легитимных приложений, а не для боевых исследований опасного кода.

Требуются ли API-ключи для работы с AI-агентами в REA?

Да, REA использует LLM-модели для интерпретации поведения, и для этого нужен доступ к API. Поддерживаются Claude, GPT и некоторые open-source модели через Ollama. Без ключа инструмент может собирать трассировки, но не сможет генерировать описание поведения на естественном языке.

Как REA справляется с приложениями, которые активно пытаются обнаружить анализ?

Это зависит от уровня изоляции. REA использует контейнеры и ptrace, но продвинутые приложения могут проверять окружение на признаки виртуализации. В таких случаях эффективность падает, и лучше переключаться на эмуляцию через QEMU или отдельную физическую машину. REA не претендует на универсальное решение для антианализирующего ПО.

Можно ли интегрировать REA в CI/CD pipeline для автоматической проверки бинарников?

Да, это одно из основных применений. REA выводит результаты в JSON, который легко парсить в скриптах. Можно настроить шаг в pipeline, который анализирует каждый новый билд и проверяет, не появилось ли подозрительного поведения. Главное — убедиться, что контейнеры в CI достаточно изолированы, чтобы анализируемый код не мог вырваться наружу.

Поделиться:TelegramX / TwitterVK

Читайте также

VoltAgent awesome-design-md: дизайн-системы для агентов

Разбор коллекции DESIGN.md от VoltAgent — как готовые спецификации дизайн-систем помогают ИИ-агентам генерировать единый UI без ручной настройки токенов.

7 сентября 2026 г.12 мин
Продвинутый