trickster0/offensiverustArmamentización en Rust para Ejercicios de Red Team.
Mis experimentos en convertir Rust en un arma para el desarrollo de implantes y operaciones ofensivas generales.
mingw, aunque ciertas bibliotecas no se pueden compilar con éxito en otros SO.Este repositorio no proporciona binarios, tendrás que compilarlos tú mismo.
Instalar Rust Simplemente descarga el binario e instálalo.
Este repositorio fue compilado en Windows 10, por lo que me ceñiría a eso. Como se mencionó, los binarios de OpenSSL tendrán problemas de dependencias que requerirán tener instalados OpenSSL y perl.
Para el cliente/servidor TCP SSL recomiendo compilación estática debido a las dependencias en los hosts donde ejecutarás los binarios.
Para crear un proyecto, ejecuta:
cargo new <name>
Esto creará automáticamente las carpetas estructuradas del proyecto con:```bash
project
├── Cargo.toml
└── src
└── main.rs
Cargo.toml es el archivo que contiene las dependencias y la configuración para la compilación.
main.rs es el archivo principal que se compilará junto con cualquier directorio potencial que contenga bibliotecas.
Para compilar el proyecto, entra en el directorio del proyecto y ejecuta:
`cargo build`
Esto usará tu cadena de herramientas predeterminada.
Si deseas compilar la versión final "release", ejecuta:
`cargo build --release`
Para binarios estáticos, en la terminal antes del comando de compilación ejecuta:
`"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"`
`set RUSTFLAGS=-C target-feature=+crt-static`
En caso de que no te sea fácil leer mi código tal como está escrito,
también puedes usar el comando siguiente dentro del directorio del proyecto para formatearlo de una mejor manera
`cargo fmt`
Ciertos ejemplos podrían no compilar y darte algún error, ya que podría requerir una versión nightly
de Rust con las características más recientes. Para instalarla solo haz:
`rustup default nightly`
El lugar más fácil para encontrar las dependencias o [Crates](https://crates.io/) como se les llama.
## Cross Compiling
La compilación cruzada requiere seguir las instrucciones [aquí](https://rust-lang.github.io/rustup/cross-compilation.html)
Instalando diferentes cadenas de herramientas, puedes compilar de forma cruzada con el siguiente comando
`cargo build --target <toolchain>`
Para ver las cadenas de herramientas instaladas en tu sistema ejecuta:
`rustup toolchain list`
Para verificar todas las cadenas de herramientas disponibles que puedes instalar en tu sistema ejecuta:
`rustup target list`
Para instalar una nueva cadena de herramientas ejecuta:
`rustup target add <toolchain_name>`
## Optimizing executables for size
Este [repositorio](https://github.com/johnthagen/min-sized-rust) contiene muchas opciones de configuración e ideas sobre cómo reducir el tamaño del archivo.
Los binarios estáticos suelen ser bastante grandes.
## Pitfalls I found myself falling into
Cuidado con los bytes \0, no los olvides para las cadenas en memoria, pasé mucho tiempo pero windbg siempre ayudó a resolverlo.
## Interesting Rust libraries
- WINAPI
- [WINAPI2](https://github.com/MauriceKayser/rs-winapi2)
- Windows - Este es el oficial de Microsoft con el que no he jugado mucho
## OPSEC
- Aunque Rust tiene buenas ventajas, es bastante difícil acostumbrarse a él y no es muy intuitivo.
- La generación de shellcode es otro problema debido a LLVM. He encontrado algunas formas de abordar esto.
[Donut](https://github.com/TheWover/donut) a veces genera shellcode que funciona, pero dependiendo de cómo esté hecho el proyecto, podría no hacerlo.
En general, para la generación de shellcode, las herramientas que se crean deben estar hechas para alojar todo el código en el segmento .text,
lo que lleva a este increíble [repositorio](https://github.com/b1tg/rust-windows-shellcode).
Hay un ejemplo de shellcode en este proyecto que puede mostrarte cómo estructurar tu código para una generación exitosa de shellcode.
Además, este proyecto también tiene un generador de shellcode que toma el segmento .text de un binario y
extrae el shellcode después de ejecutar algunos parches.
Este proyecto toma el binario de una ubicación específica, así que hice un fork que recibe la ruta del binario como argumento [aquí](https://github.com/trickster0/rust-windows-shellcode-custom).
- Incluso si eliminas todos los símbolos de depuración, Rust aún puede mantener referencias a tu directorio home en el binario. La única forma que he encontrado para eliminar esto es pasar la siguiente bandera: `--remap-path-prefix {tu directorio home}={algún identificador aleatorio}`. Puedes usar variables bash para obtener tu directorio home y generar un marcador de posición aleatorio: `--remap-path-prefix "$HOME"="$RANDOM"`. (Por [Yamakadi](https://github.com/yamakadi))
- Aunque para lo anterior hay otra forma de eliminar información sobre el directorio home añadiendo al principio de Cargo.toml
`cargo-features = ["strip"]` .
Dado que Rust por defecto deja muchas cosas como cadenas en el binario, normalmente uso este [cargo.toml](../master/cargo.toml) para evitarlas y también reducir el tamaño
con el comando de compilación
`cargo build --release -Z build-std=std,panic_abort -Z build-std-features=panic_immediate_abort --target x86_64-pc-windows-msvc`
- [Yamakadi] también señaló que dependiendo de las bibliotecas importadas, el stripping no siempre es consistente para ocultar el directorio home, por lo que una combinación de su solución para reasignar la ruta y usar el cargo anterior funcionaría mejor. Intenta estar atento y revisa tus binarios antes de ejecutarlos en tus compromisos para detectar posibles cadenas que no se hayan eliminado correctamente.
## Other projects I have have made in Rust
- [UDPlant](https://github.com/trickster0/UDPlant) - Básicamente una reverse shell UDP
- [EDR Detector](https://github.com/trickster0/EDR_Detector) - Detecta los EDR del sistema instalado según los archivos .sys instalados
- [Lenum](https://github.com/trickster0/Lenum) - Una herramienta simple de enumeración Unix
## Projects in Rust that can be hepfull
- [houdini](https://github.com/yamakadi/houdini) - Ayuda a que tu ejecutable se autodestruya
| Archivo | Descripción |
|---|
| Allocate_With_Syscalls | Usa funciones de NTDLL directamente con la biblioteca ntapi |
| Create_DLL | Crea una DLL y muestra un msgbox, Rust no soporta esto completamente, por lo que las cosas pueden volverse extrañas ya que las DLL de Rust no tienen función main |
| DeviceIoControl | Abre un manejador de controlador y ejecuta DeviceIoControl |
| EnableDebugPrivileges | Habilitar SeDebugPrivilege en el proceso actual |
| Shellcode_Local_inject | Ejecuta shellcode directamente en el proceso local mediante la conversión de puntero |
| Execute_With_CMD | Ejecuta cmd pasando un comando a través de Rust |
| ImportedFunctionCall | Importa minidump de dbghelp y lo ejecuta |
| Kernel_Driver_Exploit | Exploit de controlador de kernel para un desbordamiento de búfer simple |
| Named_Pipe_Client | Cliente de tubería con nombre |
| Named_Pipe_Server | Servidor de tubería con nombre |
| PEB_Walk | Resolver e invocar APIs de Windows dinámicamente |
| Process_Injection_CreateThread | Inyección de procesos en un proceso en ejecución con CreateThread |
| Process_Injection_CreateRemoteThread | Inyección de procesos en un proceso remoto con CreateRemoteThread |
| Process_Injection_Self_EnumSystemGeoID | Autoinyector que utiliza la llamada a la API EnumSystemsGeoID para ejecutar shellcode. |
| Unhooking | Llamadas de desenganche |
| asm_syscall | Obtener la dirección del PEB mediante asm |
| base64_system_enum | Codificación/decodificación de cadenas en Base64 |
| http-https-requests | Solicitudes HTTP/S ignorando la verificación de certificados para GET/POST |
| patch_etw | Parchear ETW |
| ppid_spoof | Suplantar el proceso padre para el proceso creado |
| tcp_ssl_client | Cliente TCP con SSL que ignora la verificación de certificados (Requiere tener instalados openssl y perl para compilar) |
| tcp_ssl_server | Servidor TCP, con parámetro de puerto (Requiere tener instalados openssl y perl para compilar) |
| wmi_execute | Ejecuta una consulta WMI para obtener los AV/EDR en el host |
| Windows.h+ Bindings | Este archivo contiene estructuras de Windows.h más LDR, PEB, etc. personalizados completos que no están documentados oficialmente por Microsoft, agregue al principio de su archivo include!("../bindings.rs"); |
| UUID_Shellcode_Execution | Planta shellcode desde un array UUID en el espacio del montón y usa el callback EnumSystemLocalesA para ejecutar el shellcode. |
| AMSI Bypass | Bypass de AMSI en el proceso local |
| Injection_AES_Loader | Inyección NtTestAlert con descifrado AES |
| Litcrypt_String_Encryption | Usando la crate Litcrypt para cifrar cadenas literales en reposo y en memoria para derrotar el AV estático. |
| Api Hooking | Api Hooking usando la librería detour |
| memfd_create | Ejecutar payloads desde memoria usando la técnica memfd_create (para Linux) |
| RC4_Encryption | Shellcode descifrado con RC4 |
| Steal Token | Robar token de un proceso |
| Keyboard Hooking | Keylogging mediante hooking del teclado con SetWindowsHookEx |
| memN0ps arsenal: shellcode_runner_classic-rs | Clásico runner/injector de shellcode usando ntapi |
| memN0ps arsenal: dll_injector_classic-rs | Inyección clásica de DLL usando windows-sys |
| memN0ps arsenal: module_stomping-rs | Module Stomping / Module Overloading / DLL Hollowing usando windows-sys |
| memN0ps arsenal: obfuscate_shellcode-rs | Ofuscador simple de shellcode con XOR y AES |
| memN0ps arsenal: process_hollowing-rs | Process Hollowing usando ntapi |
| memN0ps arsenal: rdi-rs | Inyección reflectante de DLL usando windows-sys |
| memN0ps: eagle-rs | Rusty Rootkit: Controlador de kernel de Windows en Rust para Red Teamers usando winapi y ntapi |
| memN0ps: psyscalls-rs | Librería Rusty Parallel Syscalls usando winapi |
| memN0ps: mmapper-rs | Mapeador manual Rusty usando winapi |
| memN0ps: srdi-rs | Inyección reflectante de DLL en shellcode Rusty usando windows-sys |
| memN0ps: mordor-rs - freshycalls_syswhispers | Librería Rusty FreshyCalls / SysWhispers1 / SysWhispers2 / SysWhispers3 usando windows-sys |
| memN0ps: mordor-rs - hells_halos_tartarus_gate | Librería Rusty Hell's Gate / Halo's Gate / Tartarus' Gate usando windows-sys |
| memN0ps: pemadness-rs | Librería Rusty de análisis de ejecutables portátiles (PE Parsing Library) usando windows-sys |
| memN0ps: mimiRust | Mimikatz hecho en Rust por @ThottySploit. El autor original eliminó su cuenta de GitHub, por lo que se ha subido para uso de la comunidad. |
| memN0ps and trickster0: ekko-rs | Rusty Ekko - Ofuscación de sueño en Rust usando windows-sys. |