Реализация многопоточного сканирования уязвимостей на Android‑устройствах с помощью Rust‑библиотек в Termux

Termux — удобная среда для выполнения прикладных задач на Android, включая разработку и запуск собственных инструментов безопасности. В этом материале я, Денис Евгеньевич Усачёв (ведущий эксперт РыбинскЛАБ), покажу, как подойти к реализации многопоточного сканирования уязвимостей на Android‑устройствах в Termux с применением Rust‑библиотек и корректной архитектурой.

Важно: любые действия по «сканированию» и проверке уязвимостей должны выполняться только в рамках закона РФ и при наличии явных полномочий на тестируемые системы. Ниже будут рассмотрены принципы построения инструмента, рассчитанного на легитимные сценарии (например, аудит собственных стендов, тестирование в рамках внутреннего периметра, лабораторные стенды).

Правовой и практический контекст для Android‑сканера

В реальной эксплуатации критично зафиксировать:

Целевое разрешение на тестируемые хосты/сервисы (внутренние активы компании, лабораторные стенды, системы с оформленным допуском).
Ограничения по нагрузке: сканирование должно быть rate-limited и управляемым по числу одновременных задач.
Прозрачность целей: инструмент должен быть ориентирован на проверку конкретных гипотез/сигнатур и протоколировать результат.
Безопасность самого инструмента: минимизация прав, отказ от небезопасного хранения секретов, корректная обработка исключений.

Если вы работаете в лаборатории и используете VPN, рассматривайте его только как способ организовать локальную сеть/доступ к стенду, а не для обхода блокировок.

Архитектура: как сочетать Termux и Rust

Оптимальная схема для Android‑устройства в Termux выглядит так:

Termux — подготовка окружения, сборка/запуск, управление зависимостями.
Rust-клиент — основная логика сканера: многопоточность/асинхронность, сеть, парсинг ответов, агрегация результатов.
Результаты — вывод в JSON/CSV, логирование прогресса и ошибок.
Пороговые ограничения — лимит параллелизма, таймауты, политика ретраев.

Практически удобно сделать Rust‑приложение (или библиотеку + бинарник), которое:

принимает список целей (IP/домены/диапазоны) из входного файла;
работает через пул задач (thread pool или async runtime);
выполняет контролируемые проверки (например, проверка доступности порта и получение минимально необходимой информации);
агрегирует результаты в структурированном виде.

Модель многопоточности: потоковый пул vs async

В Rust на практике встречаются два подхода:

Thread pool (например, через rayon или ручные потоки) — хорошо для задач с CPU-нагрузкой или для очень простого сетевого кода при умеренном числе соединений.
Async (например, tokio) — обычно лучше для сетевого сканирования при большом числе одновременных соединений за счет неблокирующего I/O.

Для Android‑устройств с ограниченными ресурсами я рекомендую async + лимит параллелизма: так вы сможете безопаснее управлять нагрузкой и временем ожидания.

Подготовка окружения в Termux

Для работы с Rust в Termux обычно используют установку toolchain и базовых пакетов. Примерные шаги:

# Обновите пакеты
pkg update && pkg upgrade -y

# Установите зависимости
pkg install -y clang git curl pkg-config openssl

# Установите Rust (rustup) — если еще не установлен
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Перезапустите shell или подхватите PATH
# (часто требуется выполнить команду вида source ...)

Если у вас уже есть Rust toolchain, переходите к сборке проекта.

Создание Rust-проекта под сканер

Создадим типовой проект и заложим зависимости: асинхронный runtime, управление конкуренцией и сериализация результатов.

cargo new vulnscan-mobile --bin
cd vulnscan-mobile

Далее отредактируем Cargo.toml. Пример:

[package]
name = "vulnscan-mobile"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
clap = { version = "4", features = ["derive"] }

# Для лимита параллелизма удобно использовать Semaphore из tokio.

Пример кода: управляемая многозадачность и агрегация результатов

Ниже — безопасный шаблон многопоточного/многозадачного каркаса: он показывает, как ограничить параллелизм, задать таймауты и собрать результаты. Конкретные «проверки» лучше реализовывать под разрешенные сценарии вашей лаборатории.

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

use clap::Parser;
use serde::Serialize;
use std::{net::SocketAddr, sync::Arc, time::Duration};
use tokio::{net::TcpStream, sync::Semaphore, time::timeout};

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    /// Список целей в формате host:port, например 192.168.1.10:80
    #[arg(long)]
    targets: Vec,

    /// Максимум параллельных задач
    #[arg(long, default_value_t = 32)]
    concurrency: usize,

    /// Таймаут на сетевую операцию
    #[arg(long, default_value_t = 3)]
    timeout_seconds: u64,
}

#[derive(Serialize, Debug, Clone)]
struct CheckResult {
    target: String,
    ok: bool,
    detail: String,
}

async fn check_target(target: String, sem: Arc, timeout_seconds: u64) -> CheckResult {
    let _permit = sem.acquire().await.expect("semaphore closed");

    // Валидация минимального формата
    let addr: SocketAddr = match target.parse() {
        Ok(a) => a,
        Err(_) => {
            return CheckResult { target, ok: false, detail: "Invalid target format".into() };
        }
    };

    let dur = Duration::from_secs(timeout_seconds);

    // Пример нейтральной проверки: установление TCP-соединения.
    // Детальные проверки сигнатур/уязвимостей лучше делать только в рамках вашего разрешенного стенда.
    let connect_res = timeout(dur, TcpStream::connect(addr)).await;

    match connect_res {
        Ok(Ok(_stream)) => CheckResult {
            target,
            ok: true,
            detail: "TCP connect: success (no vuln claim)".into(),
        },
        Ok(Err(e)) => CheckResult {
            target,
            ok: false,
            detail: format!("TCP connect error: {}", e),
        },
        Err(_) => CheckResult {
            target,
            ok: false,
            detail: "TCP connect: timeout".into(),
        },
    }
}

#[tokio::main]
async fn main() {
    let args = Args::parse();

    let sem = Arc::new(Semaphore::new(args.concurrency));

    let mut handles = Vec::new();
    for t in args.targets {
        let sem = sem.clone();
        let to = args.timeout_seconds;
        handles.push(tokio::spawn(async move { check_target(t, sem, to).await }));
    }

    let mut results = Vec::new();
    for h in handles {
        match h.await {
            Ok(r) => results.push(r),
            Err(e) => results.push(CheckResult {
                target: "unknown".into(),
                ok: false,
                detail: format!("task join error: {}", e),
            }),
        }
    }

    // Вывод в JSON — удобно для дальнейшего анализа
    println!("{}", serde_json::to_string_pretty(&results).unwrap());
}

Этот пример намеренно не делает утверждений об «уязвимости» — он иллюстрирует правильную инженерную основу: concurrency limit, таймауты, структурированный вывод. Под «реальными» проверками уязвимостей подразумевается ваша конкретная методика тестирования на авторизованных системах.

Сборка и запуск в Termux

Соберите проект и запустите:

cargo build --release

# Пример запуска
./target/release/vulnscan-mobile \
  --targets 192.168.1.10:80 192.168.1.11:443 \
  --concurrency 16 \
  --timeout-seconds 3

На выходе вы получите JSON с результатами по каждой цели.

Как расширять проверки под легитимные сценарии аудита

Чтобы перейти от «нейтральной доступности» к проверкам на уязвимости в рамках дозволенного аудита, соблюдайте инженерные и этические принципы:

Используйте точечные, минимально-инвазивные запросы (только то, что нужно для оценки).
Добавьте строгие таймауты и ретраи с паузами.
Ограничивайте параллелизм (например, семафор, как в примере).
Логируйте контекст: какие проверки выполнялись и почему.
Не делайте агрессивные фазы (мульти-пакеты, эксплуатационные шаги) без отдельного разрешения и методики.

Если вы делаете собственные сигнатурные проверки (например, сравнение заголовков/ответов протокола), лучше хранить правила в конфиге, а код держать максимально простым и тестируемым.

Производительность и устойчивость на Android

Для улучшения стабильности на мобильных устройствах:

Таймауты: задавайте отдельно на DNS/соединение/чтение (если используете чтение после connect).
Контроль памяти: не копируйте большие буферы на каждую задачу; используйте небольшие чтения.
Событийный прогресс: выводите прогресс периодически, а не на каждый пакет (иначе будет тормозить).
Сетевые ограничения: мобильные сети нестабильны; ретраи планируйте аккуратно.

Тестирование: лабораторный контур и воспроизводимость

Рекомендуемый подход для разработки и валидации сканера:

Создайте лабораторный контур (несколько хостов/контейнеров), где известны ожидаемые результаты.
Сравнивайте вывод инструмента с эталонной методикой (ручная проверка или регламент).
Проводите нагрузочные прогоны на ограниченной выборке, затем увеличивайте консервативно параллелизм.

При необходимости VPN применяйте только для создания локальной сети и доступа к вашему стенду, с соблюдением политики безопасности.

Заключение

Многопоточное/многозадачное сканирование уязвимостей в Termux на Android реалистично и удобно реализовать через Rust‑библиотеки: ключ к качеству — это управляемая конкуренция (семофор/пул задач), строгие таймауты, корректная агрегация результатов и внимательное соблюдение легитимного поля применения. Предложенный каркас поможет вам создать надежный инструмент для аудита в авторизованных средах, а дальше — аккуратно расширять логику под ваши методики.

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