trickster0/offensiverustWeaponizzazione di Rust per operazioni di Red Team.
I miei esperimenti nell'armare Rust per lo sviluppo di implant e operazioni offensive in generale.
mingw, anche se alcune librerie non possono essere compilate con successo su altri sistemi operativi.Questo repository non fornisce binari, dovrete compilarli voi stessi.
Installa Rust
Basta scaricare il binario e installarlo.
Questo repo è stato compilato su Windows 10, quindi mi atterrei a quello. Come accennato, i binari OpenSSL avranno problemi di dipendenze che richiederanno l'installazione di OpenSSL e perl.
Per il client/server TCP SSL, consiglio una build statica a causa delle dipendenze sugli host in cui eseguirete i binari.
Per creare un progetto, esegui:
cargo new <nome>
Questo creerà automaticamente le cartelle di progetto strutturate con:```bash
project
├── Cargo.toml
└── src
└── main.rs
Cargo.toml è il file che contiene le dipendenze e la configurazione per la compilazione.
main.rs è il file principale che verrà compilato insieme a eventuali directory contenenti librerie.
Per compilare il progetto, entrare nella directory del progetto ed eseguire:
`cargo build`
Questo utilizzerà la toolchain predefinita.
Se si desidera compilare la versione finale "release", eseguire:
`cargo build --release`
Per binari statici, nel terminale prima del comando di build eseguire:
`"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"`
`set RUSTFLAGS=-C target-feature=+crt-static`
Nel caso non ti sia facile leggere il mio codice così com'è scritto,
puoi anche usare il comando seguente all'interno della directory del progetto per formattarlo in modo migliore
`cargo fmt`
Alcuni esempi potrebbero non compilare e dare qualche errore, poiché potrebbero richiedere una nightly build di Rust con le funzionalità più recenti. Per installarla basta fare:
`rustup default nightly`
Il posto più facile per trovare le dipendenze o [Crates](https://crates.io/) come vengono chiamati.
## Cross Compiling
La cross-compilazione richiede di seguire le istruzioni [qui](https://rust-lang.github.io/rustup/cross-compilation.html)
Installando diverse toolchain, puoi cross-compilare con il comando seguente
`cargo build --target <toolchain>`
Per vedere le toolchain installate sul tuo sistema esegui:
`rustup toolchain list`
Per controllare tutte le toolchain disponibili che puoi installare sul tuo sistema esegui:
`rustup target list`
Per installare una nuova toolchain esegui:
`rustup target add <toolchain_name>`
## Ottimizzare gli eseguibili per le dimensioni
Questo [repo](https://github.com/johnthagen/min-sized-rust) contiene molte opzioni di configurazione e idee per ridurre le dimensioni del file.
I binari statici sono solitamente piuttosto grandi.
## Insidie in cui mi sono imbattuto
Attenzione ai byte \0, non dimenticateli per le stringhe in memoria, ho passato molto tempo ma windbg ha sempre aiutato a risolverlo.
## Librerie Rust interessanti
- WINAPI
- [WINAPI2](https://github.com/MauriceKayser/rs-winapi2)
- Windows - Questo è quello ufficiale Microsoft con cui non ho giocato molto
## OPSEC
- Anche se Rust ha buoni vantaggi, è piuttosto difficile abituarsi e non è molto intuitivo.
- La generazione di shellcode è un altro problema a causa di LLVM. Ho trovato alcuni modi per affrontarlo.
[Donut](https://github.com/TheWover/donut) a volte genera shellcode che funziona, ma a seconda di come è realizzato il progetto, potrebbe non funzionare.
In generale, per la generazione di shellcode, gli strumenti realizzati dovrebbero essere fatti per ospitare tutto il codice nel segmento .text, il che porta a questo fantastico [repo](https://github.com/b1tg/rust-windows-shellcode).
C'è un esempio di shellcode in questo progetto che può mostrarti come strutturare il tuo codice per una generazione di shellcode di successo.
Inoltre, questo progetto ha anche un generatore di shellcode che cattura il segmento .text di un binario e scarica lo shellcode dopo aver eseguito alcune patch.
Questo progetto prende il binario da una posizione specifica, quindi ho creato un fork che riceve il percorso del binario come argomento [qui](https://github.com/trickster0/rust-windows-shellcode-custom).
- Anche se rimuovi tutti i simboli di debug, rust può comunque mantenere riferimenti alla tua home directory nel binario. L'unico modo che ho trovato per rimuoverli è passare il seguente flag: `--remap-path-prefix {your home directory}={some random identifier}`. Puoi usare variabili bash per ottenere la tua home directory e generare un segnaposto casuale: `--remap-path-prefix "$HOME"="$RANDOM"`. (Da [Yamakadi](https://github.com/yamakadi))
- Sebbene per quanto sopra ci sia un altro modo per rimuovere informazioni sulla home directory aggiungendo all'inizio di Cargo.toml
`cargo-features = ["strip"]` .
Poiché Rust per impostazione predefinita lascia molte cose come stringhe nel binario, uso principalmente questo [cargo.toml](../master/cargo.toml) per evitarle e anche ridurre le dimensioni
con il comando di build
`cargo build --release -Z build-std=std,panic_abort -Z build-std-features=panic_immediate_abort --target x86_64-pc-windows-msvc`
- [Yamakadi] ha anche sottolineato che, a seconda delle librerie importate, lo stripping non è sempre coerente nel nascondere la home directory, quindi una combinazione della sua soluzione per rimappare il percorso e usare il cargo sopra funzionerebbe meglio. Cerca di essere consapevole e controlla i tuoi binari prima di eseguirli nei tuoi impegni per potenziali stringhe che non sono state rimosse correttamente.
## Altri progetti che ho realizzato in Rust
- [UDPlant](https://github.com/trickster0/UDPlant) - Fondamentalmente una reverse shell UDP
- [EDR Detector](https://github.com/trickster0/EDR_Detector) - Rileva gli EDR del sistema installato in base ai file .sys installati
- [Lenum](https://github.com/trickster0/Lenum) - Un semplice strumento di enumerazione Unix
## Progetti in Rust che possono essere utili
- [houdini](https://github.com/yamakadi/houdini) - Aiuta a rendere il tuo eseguibile auto-eliminante
| File | Descrizione |
|---|
| Allocate_With_Syscalls | Utilizza direttamente le funzioni NTDLL con la libreria ntapi |
| Create_DLL | Crea una DLL e mostra una msgbox. Rust non supporta completamente questa funzionalità, quindi le cose potrebbero diventare strane poiché le DLL Rust non hanno una funzione main. |
| DeviceIoControl | Apre un handle del driver ed esegue DeviceIoControl |
| EnableDebugPrivileges | Abilita SeDebugPrivilege nel processo corrente |
| Shellcode_Local_inject | Esegue shellcode direttamente nel processo locale tramite puntatore |
| Execute_With_CMD | Esegue cmd passando un comando tramite Rust |
| ImportedFunctionCall | Importa minidump da dbghelp e lo esegue |
| Kernel_Driver_Exploit | Exploit per driver kernel per un semplice buffer overflow |
| Named_Pipe_Client | Client Named Pipe |
| Named_Pipe_Server | Server Named Pipe |
| PEB_Walk | Risolve dinamicamente e invoca API Windows |
| Process_Injection_CreateThread | Iniezione di processo in un processo in esecuzione con CreateThread |
| Process_Injection_CreateRemoteThread | Iniezione di processo in un processo remoto con CreateRemoteThread |
| Process_Injection_Self_EnumSystemGeoID | Self injector che utilizza la chiamata API EnumSystemsGeoID per eseguire shellcode. |
| Unhooking | Chiamate Unhooking |
| asm_syscall | Ottenere l'indirizzo PEB tramite asm |
| base64_system_enum | Codifica/decodifica di stringhe Base64 |
| http-https-requests | Richieste HTTP/S ignorando il controllo del certificato per GET/POST |
| patch_etw | Patch ETW |
| ppid_spoof | Spoof del processo padre per il processo creato |
| tcp_ssl_client | Client TCP con SSL che ignora il controllo del certificato (richiede l'installazione di openssl e perl per la compilazione) |
| tcp_ssl_server | Server TCP, con parametro porta (richiede l'installazione di openssl e perl per la compilazione) |
| wmi_execute | Esegue una query WMI per ottenere gli AV/EDR sull'host |
| Windows.h+ Bindings | Questo file contiene strutture di Windows.h più LDR, PEB, ecc. personalizzati e non documentati ufficialmente da Microsoft. Aggiungi in cima al tuo file: include!("../bindings.rs"); |
| UUID_Shellcode_Execution | Inserisce shellcode da un array UUID nello spazio heap e utilizza la callback EnumSystemLocalesA per eseguire lo shellcode. |
| AMSI Bypass | Bypass AMSI sul processo locale |
| Injection_AES_Loader | Iniezione NtTestAlert con decifratura AES |
| Litcrypt_String_Encryption | Utilizzo del crate Litcrypt per cifrare stringhe letterali in memoria e a riposo per sconfiggere l'AV statico. |
| Api Hooking | Api Hooking utilizzando la libreria detour |
| memfd_create | Eseguire payload dalla memoria utilizzando la tecnica memfd_create (Per Linux) |
| RC4_Encryption | Shellcode decifrato con RC4 |
| Steal Token | Rubare token da un processo |
| Keyboard Hooking | Keylogging agganciando la tastiera con SetWindowsHookEx |
| memN0ps arsenal: shellcode_runner_classic-rs | Esecutore/iniettore classico di shellcode usando ntapi |
| memN0ps arsenal: dll_injector_classic-rs | Iniezione classica di DLL usando windows-sys |
| memN0ps arsenal: module_stomping-rs | Module Stomping / Module Overloading / DLL Hollowing usando windows-sys |
| memN0ps arsenal: obfuscate_shellcode-rs | Semplice offuscatore di shellcode XOR e AES |
| memN0ps arsenal: process_hollowing-rs | Process Hollowing usando ntapi |
| memN0ps arsenal: rdi-rs | Iniezione riflessiva di DLL usando windows-sys |
| memN0ps: eagle-rs | Rusty Rootkit: Driver kernel Windows in Rust per Red Teamers usando winapi e ntapi |
| memN0ps: psyscalls-rs | Libreria Rusty Parallel Syscalls usando winapi |
| memN0ps: mmapper-rs | Rusty Manual Mapper usando winapi |
| memN0ps: srdi-rs | Iniezione riflessiva di shellcode Rusty usando windows-sys |
| memN0ps: mordor-rs - freshycalls_syswhispers | Libreria Rusty FreshyCalls / SysWhispers1 / SysWhispers2 / SysWhispers3 usando windows-sys |
| memN0ps: mordor-rs - hells_halos_tartarus_gate | Libreria Rusty Hell's Gate / Halo's Gate / Tartarus' Gate usando windows-sys |
| memN0ps: pemadness-rs | Libreria Rusty Portable Executable Parsing (Libreria per il parsing PE) usando windows-sys |
| memN0ps: mimiRust | Mimikatz realizzato in Rust da @ThottySploit. L'autore originale ha eliminato il suo account GitHub, quindi è stato caricato per uso comunitario. |
| memN0ps and trickster0: ekko-rs | Rusty Ekko - Offuscamento del sonno in Rust usando windows-sys. |