optiv/scarecrowScareCrow - Framework di creazione payload progettato per il bypass dell'EDR.
Per visualizzare l'ultima versione di ScareCrow o per inviare un problema, fare riferimento a https://github.com/Tylous/ScareCrow.
Se vuoi saperne di più sulle tecniche utilizzate in questo framework, dai un'occhiata alla Parte 1 e alla Parte 2
ScareCrow è un framework per la creazione di payload per il side loading (non l'iniezione) in un processo Windows legittimo (bypassando i controlli di Application Whitelisting). Una volta che il loader DLL viene caricato in memoria, utilizza una tecnica per rimuovere gli hook di un EDR dalle DLL di sistema in esecuzione nella memoria del processo. Questo funziona perché sappiamo che gli hook dell'EDR vengono posizionati quando un processo viene creato.
ScareCrow può colpire queste DLL e manipolarle in memoria utilizzando la funzione API VirtualProtect, che cambia i permessi di una sezione della memoria di un processo in un valore diverso, in particolare da Execute–Read a Read-Write-Execute.
ScareCrow utilizza 1 dei 2 metodi per rimuovere gli hook
Quando viene eseguito, ScareCrow copia i byte delle DLL di sistema memorizzate su disco in C:\Windows\System32\. Queste DLL sono memorizzate su disco "pulite" dagli hook dell'EDR perché vengono utilizzate dal sistema per caricare una copia inalterata in un nuovo processo quando viene creato. Poiché gli EDR hookano solo questi processi in memoria, rimangono inalterati. ScareCrow non copia l'intero file DLL, ma si concentra solo sulla sezione .text delle DLL. Questa sezione di una DLL contiene l'assembly eseguibile, e facendo ciò, ScareCrow aiuta a ridurre la probabilità di rilevamento poiché la rilettura di interi file potrebbe far sì che un EDR rilevi una modifica a una risorsa di sistema. I dati vengono quindi copiati nella giusta regione di memoria utilizzando l'offset di ciascuna funzione. Ogni funzione ha un offset che indica il numero esatto di byte dall'indirizzo di base in cui risiede, fornendo la posizione della funzione sullo stack.
Per fare ciò, ScareCrow cambia i permessi della regione di memoria .text utilizzando VirtualProtect. Anche se si tratta di una DLL di sistema, poiché è stata caricata nel nostro processo (che controlliamo), possiamo cambiare i permessi di memoria senza richiedere privilegi elevati.
ScareCrow carica lo shellcode in memoria decrittandolo prima, il quale è crittografato con uno dei tre metodi di crittografia (descritti di seguito). Una volta decrittografato e caricato, lo shellcode viene quindi eseguito. A seconda delle opzioni del loader specificate, ScareCrow imposterà diverse funzioni di esportazione per la DLL. La DLL caricata inoltre non contiene la funzione DLLMain standard che tutte le DLL tipicamente necessitano per funzionare. La DLL verrà comunque eseguita senza problemi perché il processo in cui carichiamo cercherà quelle funzioni di esportazione e non si preoccuperà della presenza di DLLMain.
Dopo
KnownDLLs è un elenco di DLL che vengono caricate da Windows durante il processo di avvio del sistema. Poiché queste DLL sono considerate essenziali per il funzionamento del sistema operativo, vengono memorizzate nella cache per ridurre i tempi di caricamento e migliorare le prestazioni all'avvio delle applicazioni. KnownDLLs include DLL come kernel32.dll, kernelbase.dll e ntdll.dll.
Utilizzando queste KnownDlls, ScareCrow mappa una copia della DLL da \KnownDlls\<dllname> utilizzando una combinazione di NtOpenSection e NtMapViewOfSection per caricarla nella memoria del processo. ScareCrow non carica l'intera DLL, ma solo la sezione .text della DLL (poiché questa contiene tutte le syscall). Da lì, ScareCrow utilizza syscall indiretti per chiamare NtProtectVirtualMemory e cambiare i permessi della sezione di memoria .text della DLL per consentire a ScareCrow di sovrascrivere gli hook dell'EDR prima di ripristinare i permessi.
Per ulteriori informazioni puoi leggere il dettagliato articolo di modexp.
Una volta rimossi gli hook, ScareCrow utilizza quindi syscall personalizzate per caricare ed eseguire shellcode in memoria. ScareCrow fa questo anche dopo che gli hook dell'EDR sono stati rimossi per aiutare a evitare il rilevamento da parte di strumenti di raccolta di telemetria non basati su userland e hook, come Event Tracing for Windows (ETW) o altri meccanismi di registrazione eventi. Queste syscall personalizzate vengono utilizzate anche per eseguire la chiamata VirtualProtect per rimuovere gli hook posizionati dagli EDR, descritta sopra, per evitare il rilevamento da qualsiasi controllo anti-manomissione degli EDR. Questo viene fatto chiamando una versione personalizzata della syscall VirtualProtect, NtProtectVirtualMemory. ScareCrow utilizza Golang per generare questi loader e poi assembly per queste funzioni syscall personalizzate.
Durante il processo di creazione del loader, ScareCrow utilizza una libreria per mimetizzarsi in background dopo che un beacon effettua il check-in. Questa libreria fa due cose:
I file firmati con certificati di firma codice sono spesso soggetti a un controllo meno approfondito, rendendo più semplice l'esecuzione senza essere contestati, poiché i file firmati da un nome fidato sono spesso meno sospetti di altri. La maggior parte dei prodotti antimalware non ha il tempo di convalidare e verificare questi certificati (ora alcuni lo fanno, ma tipicamente i nomi dei vendor comuni sono inclusi in una whitelist). ScareCrow crea questi certificati utilizzando una versione Go del tool limelighter per creare un file pfx12. Questo pacchetto prende un nome di dominio inserito dall'utente per creare un certificato di firma codice per quel dominio. Se necessario, puoi anche utilizzare il tuo certificato di firma codice, se ne hai uno, utilizzando l'opzione della riga di comando valid.
clone, insieme al percorso del file da cui copiare il certificato. Quando si firma il loader con microsoft.com, utilizzarli contro i prodotti WINDOWS DEFENDER ATP potrebbe non essere altrettanto efficace poiché possono convalidare il certificato in quanto appartiene a loro. Se stai utilizzando un loader contro un prodotto Windows, utilizza eventualmente un dominio diverso.
Con questi file e il codice Go, ScareCrow li compilerà in DLL utilizzando l'opzione della libreria c-shared. Una volta che la DLL è compilata, viene offuscata in una stringa base64 rotta che verrà incorporata in un file. Ciò consente al file di essere recuperato da remoto, accessibile ed eseguito programmaticamente.
Sebbene ScareCrow abbia un ampio elenco di attributi file, ci sono alcune circostanze in cui è necessario un set di attributi personalizzato (forse specifico per l'ambiente). Per soddisfare questa esigenza, ScareCrow consente l'inserimento di un file JSON contenente attributi. Utilizzando l'opzione della riga di comando -configfile, ScareCrow utilizzerà questi attributi e nome file invece di quelli preesistenti in ScareCrow. Il file main.json contiene un modello di esempio di come deve essere strutturato il JSON per funzionare correttamente. Nota che qualunque cosa usi come "InternalName" sarà il nome del file.
ScareCrow ora richiede golang 1.19.1 o successivo per compilare i loader. Se stai eseguendo una versione precedente, utilizza la versione 1.19.1 o successiva.
Vedi per le nuove versioni: https://golang.org/dl/.
Il primo passo come sempre è clonare il repo. Prima di compilare ScareCrow, dovrai installare le dipendenze.
Per installarle, esegui i seguenti comandi:``` go get github.com/fatih/color go get github.com/yeka/zip go get github.com/josephspurrier/goversioninfo go get github.com/Binject/debug/pe go get github.com/awgh/rawreader
Assicurati che i seguenti siano installati sul tuo OS:```
openssl
osslsigncode
mingw-w64
Quindi costruiscilo``` go build ScareCrow.go
Inoltre, ScareCrow utilizza [Garble](https://github.com/burrowers/garble) per offuscare tutti i loader.
Nota: Molte delle dipendenze non funzionano bene su Windows durante la compilazione, per questo motivo si consiglia di compilare i loader su OSX o Linux.
## Aiuto```
./ScareCrow -h
_________ _________
/ _____/ ____ _____ _______ ____ \_ ___ \_______ ______ _ __
\_____ \_/ ___\\__ \\_ __ \_/ __ \/ \ \/\_ __ \/ _ \ \/ \/ /
/ \ \___ / __ \| | \/\ ___/\ \____| | \( <_> ) /
/_______ /\___ >____ /__| \___ >\______ /|__| \____/ \/\_/
\/ \/ \/ \/ \/
(@Tyl0us)
“Fear, you must understand is more than a mere obstacle.
Fear is a TEACHER. the first one you ever had.”
Usage of ./ScareCrow:
-Evasion string
Sets the type of EDR unhooking technique:
[*] Disk - Retrives a clean version of the DLLs ".text" field from files stored on disk.
[*] KnownDLL - Retrives a clean version of the DLLs ".text" field from the KnownDLLs directory in the object namespace.
[*] None - The Loader that WILL NOT removing the EDR hooks in system DLLs and only use custom syscalls. (default "Disk")
-Exec string
Set the template to execute the shellcode:
[*] RtlCopy - Using RtlCopy to move the shellcode into the allocated address in the current running process by making a Syscall.
[*] ProcessInjection - Process Injection Mode.
[*] NtQueueApcThreadEx - Executes the shellcode by creating an asynchronous procedure call (APC) to a target thread.
[*] VirtualAlloc - Allocates shellcode into the process using custom syscalls in the current running process (default "RtlCopy")
-I string
Path to the raw 64-bit shellcode.
-Loader string
Sets the type of process that will sideload the malicious payload:
[*] binary - Generates a binary based payload. (This type does not benefit from any sideloading)
[*] control - Loads a hidden control applet - the process name would be rundll32 if -O is specified a JScript loader will be generated.
[*] dll - Generates just a DLL file. Can be executed with commands such as rundll32 or regsvr32 with DllRegisterServer, DllGetClassObject as export functions.
[*] excel - Loads into a hidden Excel process using a JScript loader.
[*] msiexec - Loads into MSIexec process using a JScript loader.
[*] wscript - Loads into WScript process using a JScript loader. (default "binary")
-O string
Name of output file (e.g. loader.js or loader.hta). If Loader is set to dll or binary this option is not required.
-clone string
Path to the file containing the certificate you want to clone
-configfile string
The path to a json based configuration file to generate custom file attributes. This will not use the default ones.
-console
Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature.
-delivery string
Generates a one-liner command to download and execute the payload remotely:
[*] bits - Generates a Bitsadmin one liner command to download, execute and remove the loader (Compatible with Binary, Control, Excel, and Wscript Loaders).
[*] hta - Generates a blank hta file containing the loader along with an MSHTA command to execute the loader remotely in the background (Compatible with Control and Excel Loaders).
[*] macro - Generates an office macro that will download and execute the loader remotely (Compatible with Control, Excel, and Wscript Loaders).
-domain string
The domain name to use for creating a fake code signing cert. (e.g. www.acme.com)
-encryptionmode string
Sets the type of encryption to encrypt the shellcode:
[*] AES - Enables AES 256 encryption.
[*] ELZMA - Enables ELZMA encryption.
[*] RC4 - Enables RC4 encryption. (default "ELZMA")
-export string
For DLL Loaders Only - Specify an Export function for a loader to have.
-injection string
Enables Process Injection Mode and specify the path to the process to create/inject into (use \ for the path).
-noamsi
Disables the AMSI patching that prevents AMSI BufferScanner.
-noetw
Disables the ETW patching that prevents ETW events from being generated.
-nosign
Disables file signing, making -domain/-valid/-password parameters not required.
-nosleep
Disables the sleep delay before the loader unhooks and executes the shellcode.
-obfu
Enables Garbles Literal flag replaces golang libray strings with more complex variants, resolving to the same value at run-time. This creates a larger loader and times longer to compile
-outpath string
The path to put the final Payload/Loader once it's compiled.
-password string
The password for code signing cert. Required when -valid is used.
-sandbox
Enables sandbox evasion using IsDomainJoined calls.
-url string
URL associated with the Delivery option to retrieve the payload. (e.g. https://acme.com/)
-valid string
The path to a valid code signing cert. Used instead -domain if a valid code signing cert is desired.
Il Loader determina il tipo di tecnica utilizzata per caricare lo shellcode nel sistema target. Se non viene scelta alcuna opzione Loader, ScareCrow compilerà semplicemente un file DLL standard, che può essere utilizzato da rundll32, regsvr32 o altre tecniche che utilizzano una DLL. ScareCrow utilizza tre diversi tipi di loader per caricare lo shellcode in memoria:
ScareCrow può anche generare payload basati su binari, se necessario, utilizzando l'opzione della riga di comando -Loader. Questi binari non beneficiano di tecniche di caricamento side-by-side, ma servono come tecnica aggiuntiva per eseguire lo shellcode a seconda della situazione.
ScareCrow utilizza una tecnica per creare prima il processo e poi spostarlo in background. Questo fa due cose: prima, aiuta a mantenere il processo nascosto e secondo, evita di essere rilevato da qualsiasi prodotto EDR. Avviare un processo immediatamente in background può essere molto sospetto e un indicatore di attività dannosa. ScareCrow lo fa chiamando le funzioni Windows 'GetConsoleWindow' e 'ShowWindow' dopo che il processo è stato creato e gli hook dell'EDR sono stati caricati, e quindi modifica gli attributi della finestra in nascosta. ScareCrow utilizza queste API anziché il tradizionale -ldflags -H=windowsgui, poiché quest'ultimo è altamente firmato e classificato nella maggior parte dei prodotti di sicurezza come indicatore di compromissione.
Se viene selezionata l'opzione della riga di comando -console, ScareCrow non nasconderà il processo in background. Invece, ScareCrow aggiungerà diversi messaggi di debug che mostrano cosa sta facendo il loader.
ScareCrow utilizza diversi template per eseguire lo shellcode. Per scegliere quale template utilizzare, usa l'opzione della riga di comando -Exec. Questi template includono:
ScareCrow ha la capacità di eseguire attacchi di process injection. Per evitare qualsiasi hook o rilevamento sia nel processo loader che nel processo iniettato stesso, ScareCrow prima rimuove gli hook dal processo loader come farebbe normalmente, per assicurarsi che non ci siano hook nel processo. Una volta completato, il loader avvierà il processo specificato nel comando di creazione. Una volta avviato, il loader creerà un handle per il processo per recuperare un elenco di DLL caricate. Una volta trovate le DLL, enumererà l'indirizzo base di ciascuna DLL nel processo remoto. Utilizzando la funzione WriteProcessMemory, il loader scriverà quindi i byte delle DLL di sistema memorizzate sul disco (poiché sono "pulite" dagli hook EDR) senza la necessità di modificare prima i permessi di memoria. ScareCrow usa WriteProcessMemory perché questa funzione contiene una caratteristica utilizzata principalmente nel debugging in cui, anche se una sezione di memoria è di sola lettura, se tutto è corretto nella chiamata a WriteProcessMemory, cambierà temporaneamente il permesso in lettura-scrittura, aggiornerà la sezione di memoria e quindi ripristinerà i permessi originali. Una volta fatto ciò, il loader può iniettare lo shellcode nel processo avviato senza problemi, poiché non ci sono hook EDR in nessuno dei due processi.
Questa opzione può essere utilizzata con qualsiasi opzione del loader. Per abilitare il process injection, usa l'opzione della riga di comando -injection insieme al percorso completo del processo in cui si desidera iniettare. Quando si inserisce il percorso come argomento, è importante racchiudere il percorso completo tra "" o utilizzare \\ doppie per ogni directory nel percorso.
ScareCrow ha la capacità di patchare le funzioni AMSI (Antimalware Scan Interface) ed ETW, impedendo la generazione di qualsiasi evento da parte del processo.
AMSI è un'API nativa di Windows che consente a Windows Defender (o ad altri prodotti antimalware) di interfacciarsi in profondità nel sistema operativo Windows e fornire una protezione avanzata, specificamente per gli attacchi basati sulla memoria. AMSI consente ai prodotti di sicurezza di rilevare meglio gli indicatori dannosi e aiutare a fermare le minacce. Poiché AMSI è nativo di Windows, i prodotti non devono "hookare" AMSI, ma piuttosto caricano la DLL necessaria per ottenere una visione approfondita del processo. Per questo motivo, ScareCrow carica la DLL AMSI.dll e poi la patch, per garantire che qualsiasi risultato dall'interfaccia di scansione risulti pulito. Patchare AMSI è predefinito in tutti i loader; se non si desidera patchare AMSI, usa l'opzione della riga di comando -noamsi per disabilitarlo nel proprio loader.
ETW utilizza Syscall incorporati per generare questa telemetria. Poiché ETW è anch'esso una funzionalità nativa integrata in Windows, i prodotti di sicurezza non hanno bisogno di "hookare" le syscall ETW per ottenere le informazioni. Di conseguenza, per prevenire ETW, ScareCrow patcha numerose syscall ETW, svuotando i registri e restituendo il flusso di esecuzione all'istruzione successiva. Patchare ETW è ora predefinito in tutti i loader; se non si desidera patchare ETW, usa l'opzione della riga di comando -noetw per disabilitarlo nel proprio loader.
Attualmente, queste opzioni funzionano solo per il processo padre; se viene utilizzata l'opzione della riga di comando -injection, il processo principale patcherà AMSI ed ETW, ma il processo iniettato
Crittografare lo shellcode è una tecnica importante utilizzata per proteggerlo dal rilevamento e dall'analisi da parte di EDR e altri prodotti di sicurezza. ScareCrow dispone di diversi metodi per crittografare lo shellcode, tra cui AES, ELZMA e RC4.
AES (Advanced Encryption Standard) è un algoritmo di crittografia simmetrica ampiamente utilizzato per crittografare i dati. ScareCrow utilizza una dimensione di 256 bit AES per crittografare lo shellcode. Il vantaggio di utilizzare AES per crittografare lo shellcode è che fornisce una crittografia forte ed è ampiamente supportato dalle librerie crittografiche. Tuttavia, l'uso di una dimensione di blocco fissa può renderlo vulnerabile a determinati attacchi, come l'attacco di padding oracle.
ELZMA è un algoritmo di compressione e crittografia spesso utilizzato nei malware per offuscare il codice. Per crittografare lo shellcode utilizzando ELZMA, lo shellcode viene prima compresso utilizzando l'algoritmo ELZMA. I dati compressi vengono quindi crittografati utilizzando una chiave casuale. I dati crittografati e la chiave vengono quindi incorporati nel codice exploit. Il vantaggio di utilizzare ELZMA per crittografare lo shellcode è che fornisce sia compressione che crittografia in un unico algoritmo. Ciò può aiutare a ridurre la dimensione del codice exploit e renderlo più difficile da rilevare.
RC4 è un algoritmo di crittografia simmetrica spesso utilizzato nei malware per crittografare lo shellcode. È un cifrario a flusso che può utilizzare chiavi di lunghezza variabile ed è noto per la sua semplicità e velocità.
L'uso dell'opzione della riga di comando -obfu abilita il flag Garbles Literal durante il processo di compilazione. Questo sostituisce qualsiasi riferimento e stringa della libreria golang con una versione più complessa, che si risolve allo stesso valore durante l'esecuzione. Questo processo richiede più tempo per essere completato, risultando in un file GO più grande. Una volta che il file è compilato, ScareCrow analizza il file appena creato, eliminando qualsiasi IOC basato su stringhe GO.
L'argomento della riga di comando per la distribuzione consente di generare un comando o una stringa di codice (nel caso della macro) per recuperare remotamente il file da una fonte remota all'host della vittima. Questi metodi di distribuzione includono: