Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
credential-attacks-toolkit — Suíte completa de ataque de credenciais para testes de segurança autorizados — SSH, FTP, Login Web, Bruteforce, Ataques de dicionário | Kitploit
Ferramentas/GitHubGitHub/amibhai/credential-attacks-toolkit
ReconhecimentoAtaques de SenhaTestes de PenetraçãoRed Teaming
GitHubamibhai/credential-attacks-toolkit

credential-attacks-toolkit

Suíte completa de ataque de credenciais para testes de segurança autorizados — SSH, FTP, Login Web, Bruteforce, Ataques de dicionário

Ver Repositório
Compartilhar
165há 3 mesesAinda não revisado
# CredAttack — Kit de Ataques de Credenciais

<p align="center">
  <img src="https://img.shields.io/badge/release-v1.3.0-brightgreen?style=for-the-badge" alt="Release">
  <img src="https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue?style=for-the-badge&amp;logo=python" alt="Python">
  <img src="https://img.shields.io/badge/protocols-17-orange?style=for-the-badge" alt="Protocols">
  <img src="https://img.shields.io/badge/tests-passing-success?style=for-the-badge&amp;logo=pytest" alt="Tests">
  <img src="https://img.shields.io/badge/license-SEE--LICENSE-lightgrey?style=for-the-badge" alt="License">
</p>

> **⚠️ AVISO LEGAL — Apenas para testes de segurança AUTORIZADOS.**  
> Usar esta ferramenta contra sistemas que você não possui ou para os quais não tem **autorização escrita explícita** é ilegal sob o Computer Fraud and Abuse Act (EUA), Computer Misuse Act (Reino Unido) e leis equivalentes em todo o mundo. Consulte [SECURITY.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/SECURITY.md).

---

## Índice

- [O que é o CredAttack?](#o-que-é-o-credattack)
- [Modos de Ataque](#modos-de-ataque)
- [Protocolos Suportados](#protocolos-suportados)
- [Arquitetura](#arquitetura)
- [Início Rápido](#início-rápido)
- [Instalação](#instalação)
- [Referência da CLI](#referência-da-cli)
- [Motor de Mutação de Senhas](#motor-de-mutação-de-senhas)
- [Base de Dados de Credenciais Padrão](#base-de-dados-de-credenciais-padrão)
- [Rotação de Proxies](#rotação-de-proxies)
- [Relatórios HTML](#relatórios-html)
- [Configuração e Variáveis de Ambiente](#configuração-e-variáveis-de-ambiente)
- [Docker](#docker)
- [Testes](#testes)
- [Estrutura do Projeto](#estrutura-do-projeto)
- [Contribuição](#contribuição)

---

## O que é o CredAttack?

O CredAttack é uma **suíte modular de testes de credenciais de nível de produção** para engajamentos autorizados de testes de penetração. Ele cobre todo o ciclo de vida de ataques de credenciais:

| Fase | Capacidade do CredAttack |
|-------|-----------------------|
| **Reconhecimento** | Base de credenciais padrão (200+ pares), geração inteligente de padrões derivados de nomes de usuário |
| **Ataque** | 17 atacantes de protocolo, 6 modos de ataque, campanhas multi-alvo |
| **Evasão** | Detecção de bloqueio, limitação de taxa configurável, jitter, rotação de proxies |
| **Relatórios** | Log de auditoria JSONL, relatório HTML Jinja2, banner de credenciais encontradas + dump em arquivo |

---

## Modos de Ataque

| Modo | Comando | Descrição |
|------|---------|-------------|
| **Dicionário** | `ssh`, `ftp`, `smb`, … | Wordlist contra um usuário |
| **Spray** | `spray` | Uma senha em uma lista de usuários (seguro contra bloqueio) |
| **Combo** | `combo` | Cada usuário × cada senha |
| **Inteligente** | `smart` | Geração de padrões derivados de nome de usuário/empresa |
| **Padrões** | `defaults` | Testa 200+ padrões conhecidos de serviços |
| **Multi-alvo** | `multi` | Mesmo ataque em uma lista de hosts |
| **Pipeline completo** | `full` | Todos os protocolos, um relatório |

---

## Protocolos Suportados

| # | Protocolo | Módulo | Porta Padrão | Observações |
|---|----------|--------|-------------|-------|
| 1 | SSH | `ssh.py` | 22 | paramiko, autenticação por chave/senha |
| 2 | FTP | `ftp.py` | 21 | Modo ativo e passivo |
| 3 | Formulário HTTP | `http_form.py` | 80/443 | Detecção automática de token CSRF |
| 4 | HTTP Basic | `http_basic.py` | 80 | RFC 7617 |
| 5 | HTTP Digest | `http_digest.py` | 80 | RFC 7616 |
| 6 | SMB | `smb.py` | 445 | impacket, NTLM |
| 7 | RDP | `rdp.py` | 3389 | impacket NLA |
| 8 | SMTP | `smtp.py` | 587 | STARTTLS |
| 9 | POP3 | `pop3.py` | 110 | Suporte a APOP |
| 10 | IMAP | `imap.py` | 143 | STARTTLS |
| 11 | MySQL | `mysql.py` | 3306 | mysql-connector-python |
| 12 | MSSQL | `mssql.py` | 1433 | pymssql |
| 13 | Redis | `redis_proto.py` | 6379 | Comando AUTH |
| 14 | MongoDB | `mongodb.py` | 27017 | pymongo |
| 15 | WinRM | `winrm.py` | 5985 | NTLM, pywinrm |
| 16 | LDAP | `ldap_proto.py` | 389 | ldap3, detecção automática de rootDSE |
| 17 | Telnet | `telnet.py` | 23 | TCP bruto |
| 18 | VNC | `vnc.py` | 5900 | DES challenge-response bruto |

---

## Arquitetura

```
credattack.py          ← shim fino: `python credattack.py ...` a partir de um checkout
│
├── credattack/cli.py   ← CLI (Typer) — 8 subcomandos de modos de ataque; também o
│                          script de console `credattack` quando instalado via pip
├── credattack/core/
│   ├── config.py      ← Configurações Pydantic v2, substituições por env-var CREDATTACK_*
│   ├── engine.py      ← AttackEngine (ThreadPoolExecutor + interface de progresso Rich)
│   ├── lockout.py     ← LockoutDetector (janela deslizante, thread-safe)
│   ├── proxy.py       ← ProxyRotator (round-robin, health-check, rebaixamento)
│   ├── mutator.py     ← PasswordMutator (leet, sazonal, sufixo, keyboard-walk…)
│   ├── result.py      ← Dataclasses AttemptResult + SessionReport
│   ├── report.py      ← Gerador de relatórios HTML Jinja2
│   └── logger.py      ← Logging Rich + gravador de auditoria JSONL
│
├── credattack/protocols/
│   └── *.py           ← 18 implementações de ProtocolAttacker
│
├── credattack/data/
│   ├── default_creds.json    ← 200+ pares reais de credenciais padrão
│   ├── smart_patterns.json   ← 140+ modelos de senhas empresariais
│   └── wordlists/            ← Listas de senhas padrão por serviço
│
└── tests/             ← 50+ testes pytest (unitários + mocks de protocolo)
```

---

## Início Rápido

```bash
# Clonar e configurar
git clone https://github.com/amibhai/credential-attacks-toolkit.git
cd credential-attacks-toolkit
python -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt

# Verificar versão
python credattack.py --version

# Dry-run (nenhuma conexão feita — verifique suas wordlists)
python credattack.py ssh -t 192.168.1.100 -u admin -P wordlists/common_passwords.txt --dry-run

# Ataque de dicionário SSH real
python credattack.py ssh -t 192.168.1.100 -u admin -P /path/to/rockyou.txt

# Password spray (com limitação de taxa, seguro contra bloqueio)
python credattack.py spray -t 192.168.1.100 --protocol ssh -U users.txt -p "Summer2024!" --delay 30

# Modo inteligente — gera padrões a partir de nome de usuário + empresa
python credattack.py smart -t 192.168.1.100 --protocol ssh -u john.doe --company ACME

# Testar padrões de serviços
python credattack.py defaults -t 192.168.1.100 --protocol mysql

# Campanha multi-alvo
python credattack.py multi --targets hosts.txt --protocol ssh -U users.txt -P passes.txt
```

---

## Instalação

### Opção A — pip + virtualenv (recomendado)

```bash
python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install --upgrade pip
pip install -r requirements.txt
```

### Opção B — Atalhos do Makefile

```bash
make install      # dependências principais
make install-dev  # + pytest-cov, ruff, mypy
```

### Opção C — pip install (editable ou a partir de um wheel)

```bash
pip install -e .          # apenas dependências principais
pip install -e .[full]    # + SMB/RDP/MySQL/MSSQL/Redis/MongoDB/WinRM/LDAP
pip install -e .[dev]     # + pytest/ruff/mypy

credattack --version      # script de console, equivalente a `python credattack.py`
```

### Opção D — Docker

```bash
docker build -t credattack -f docker/Dockerfile .
docker run --rm credattack --help

# Montar suas wordlists e coletar a saída
docker run --rm \
  -v $(pwd)/wordlists:/app/wordlists:ro \
  -v $(pwd)/output:/app/output \
  credattack ssh -t 192.168.1.100 -u admin -P wordlists/common_passwords.txt
```

---

## Referência da CLI

### Opções globais

```
python credattack.py [OPTIONS] COMMAND [ARGS]...

Options:
  -V, --version    Mostra a versão e sai.
  --help           Mostra a ajuda.
```

### Flags comuns (disponíveis em todos os comandos de protocolo)

| Flag | Curta | Padrão | Descrição |
|------|-------|---------|-------------|
| `--target` | `-t` | — | Host / IP alvo |
| `--port` | | 0 (padrão do protocolo) | Substituir porta TCP |
| `--username` | `-u` | — | Nome de usuário único |
| `--user-file` | `-U` | — | Arquivo de nomes de usuário separados por nova linha |
| `--pass-file` | `-P` | — | Arquivo de senhas separadas por nova linha |
| `--password` | `-p2` | — | Senha única |
| `--threads` | `-n` | 10 | Workers concorrentes |
| `--timeout` | `-T` | 5.0 | Timeout por tentativa (s) |
| `--delay` | `-d` | 0.0 | Atraso fixo entre tentativas (s) |
| `--jitter` | | 0.0 | Jitter aleatório máximo (s) |
| `--stop-on-first` | | True | Parar por usuário após o primeiro sucesso |
| `--proxy-file` | | None | Lista de proxies HTTP/SOCKS5 |
| `--output-dir` | `-o` | `./output` | Diretório de resultados |
| `--verbosity` | `-v` | 1 | Nível de logging (0-3) |
| `--dry-run` | | False | Contar pares sem conectar |

### Subcomandos

```bash
# Específicos por protocolo (cada um mapeia para um atacante dedicado)
python credattack.py ssh|ftp|smb|rdp|smtp|pop3|imap|mysql|mssql|redis|mongodb|winrm|ldap|telnet|vnc \
  -t HOST -u USER -P passes.txt

# HTTP (formulário / basic / digest)
python credattack.py http -t http://target/login --mode form \
  --form-user-field username --form-pass-field password --success-string "Dashboard"

# Spray — senha única, muitos usuários, atraso longo
python credattack.py spray -t HOST --protocol ssh -U users.txt -p "Password1" --delay 30

# Combo — produto cartesiano usuários × senhas
python credattack.py combo -t HOST --protocol smb -U users.txt -P passes.txt

# Inteligente — geração derivada de OSINT
python credattack.py smart -t HOST --protocol ssh -u firstname.lastname --company TargetCorp

# Padrões — testar credenciais padrão do fornecedor
python credattack.py defaults -t HOST --protocol mysql

# Multi — mesmo ataque em vários hosts
python credattack.py multi --targets hosts.txt --protocol ssh -U users.txt -P passes.txt

# Completo — todos os protocolos em sequência
python credattack.py full -t HOST -U users.txt -P passes.txt
```

---

## Motor de Mutação de Senhas

O `PasswordMutator` em `credattack/core/mutator.py` suporta estratégias combináveis:

| Estratégia | Método | Exemplo de saída |
|----------|--------|----------------|
| Leet-speak | `leet_speak(word)` | `p@ssw0rd`, `p455w0rd` |
| Capitalização | `capitalise_variants(word)` | `PASSWORD`, `Password`, `pAsSwOrD` |
| Sufixo | `suffix_append(word)` | `password123`, `password@2025` |
| Prefixo | `prefix_append(word)` | `!password`, `mypassword` |
| Keyboard-walk | `keyboard_walk(word)` | `qassword` (a→q) |
| Padrões de nome de usuário | `username_patterns(user, company)` | `john123`, `Doe1!`, `ACME2024!` |
| **Sazonal** (v1.1) | `seasonal_patterns(company)` | `Summer2024!`, `Winter25` |
| **Envoltório de caracteres especiais** (v1.1) | `special_char_wrap(word)` | `!@Password`, `Password!@` |
| Combinar | `combine(word, strategies)` | encadeia qualquer uma das acima |
| Inteligente (tudo-em-um) | `smart_generate(user, company)` | stream deduplicado e limitado |

```python
from credattack.core.mutator import PasswordMutator

m = PasswordMutator(max_mutations=5000)

# Todas as estratégias combinadas
for pw in m.smart_generate("john.doe", company="ACME"):
    print(pw)

# Apenas padrões sazonais
for pw in m.seasonal_patterns(company="Contoso"):
    print(pw)
```

---

## Base de Dados de Credenciais Padrão

`credattack/data/default_creds.json` contém **200+ pares reais de credenciais padrão** em:

Cisco · F5 · Juniper · Palo Alto · VMware · Jenkins · GitLab · Tomcat · WordPress · MySQL · MSSQL · Redis · MongoDB · PostgreSQL · Elasticsearch · RabbitMQ · Splunk · Nagios · Zabbix · pfSense · MikroTik · Huawei · HP iLO · Dell iDRAC · IPMI

```bash
# Ver todos os padrões para um serviço
python credattack.py defaults -t HOST --protocol mysql --dry-run

# Executar contra o alvo
python credattack.py defaults -t 10.0.0.1 --protocol ssh
```

---

## Rotação de Proxies

Passe um arquivo de proxies (um proxy por linha, formato `host:port`):

```
# proxies.txt
192.168.1.10:1080
192.168.1.11:1080
socks5://10.0.0.5:9050
```

```bash
python credattack.py ssh -t TARGET -u admin -P passes.txt --proxy-file proxies.txt
```

O `ProxyRotator` realiza health-checks na inicialização e rebaixa proxies que excedem um limite de taxa de falhas. Proxies mortos são excluídos automaticamente.

---

## Relatórios HTML

Após cada ataque que não seja dry-run, um relatório HTML é gerado automaticamente em `./output/`:

- **Cartões de estatísticas**: total de tentativas, taxa de sucesso, duração, tentativas/segundo
- **Tabela de credenciais encontradas**: host · protocolo · nome de usuário · senha (copiar para a área de transferência)
- **Tema escuro** — modelo Jinja2

```bash
# Abrir após uma execução
start output/report_*.html      # Windows
open  output/report_*.html      # macOS
```

---

## Configuração e Variáveis de Ambiente

Todas as configurações em `credattack/core/config.py` podem ser substituídas por variáveis de ambiente `CREDATTACK_*`:

```bash
export CREDATTACK_THREADS=20
export CREDATTACK_TIMEOUT=3.0
export CREDATTACK_DELAY=1.0
export CREDATTACK_JITTER=0.5
export CREDATTACK_LOCKOUT_THRESHOLD=3
export CREDATTACK_VERBOSITY=2
```

Ou no nível da CLI com as flags padrão (`--threads`, `--timeout`, etc.).

---

## Docker

```bash
# Construir imagem
docker build -t credattack -f docker/Dockerfile .

# Executar com Docker Compose
cd docker
docker compose run credattack ssh -t 192.168.1.100 -u admin -P /app/wordlists/common_passwords.txt

# Definir configuração via ambiente
docker run --rm \
  -e CREDATTACK_THREADS=20 \
  -e CREDATTACK_TIMEOUT=3 \
  -v $(pwd)/output:/app/output \
  credattack defaults -t 10.0.0.1 --protocol mysql
```

---

## Testes

```bash
# Executar todos os testes
pytest -q

# Com cobertura
pytest --cov=credattack --cov-report=term-missing -q

# Atalho do Makefile
make test-cov
```

**Suíte atual: 50+ testes** cobrindo:

| Área | Testes |
|------|-------|
| Detector de bloqueio (janela deslizante, segurança de thread) | `test_lockout.py` |
| Estratégias do mutador de senhas | `test_mutator.py` |
| Novas estratégias do mutador (sazonal, caracteres especiais) | `test_mutator_extended.py` |
| Rotador de proxies (health-check, rebaixamento) | `test_proxy.py` |
| Dataclasses Result & SessionReport | `test_result.py` |
| Mock do protocolo SSH | `test_protocols_ssh.py` |
| Mock do protocolo FTP | `test_protocols_ftp.py` |
| Mocks de HTTP Basic & Digest | `test_protocols_http.py` |

---

## Wordlists

> **⚠️ Os arquivos `wordlists/` incluídos são stubs mínimos de smoke-test.** Forneça os seus próprios para avaliações reais.

### Fontes recomendadas

| Wordlist | Tamanho | Melhor para |
|----------|------|----------|
| `rockyou.txt` | ~14 M | Dicionário geral |
| `SecLists/Passwords/` | Vários | Específico por protocolo |
| `kaonashi.txt` | ~64 M | Cobertura avançada |
| Derivadas de OSINT | Variável | Ataques direcionados |

```bash
# Usar qualquer wordlist externa
python credattack.py ssh -t TARGET -u admin -P /opt/wordlists/rockyou.txt
```

---

## Estrutura do Projeto

```
credential-attacks-toolkit/
├── credattack.py               # Shim fino -> credattack.cli:app (uso a partir do checkout)
├── pyproject.toml              # Configuração de build e ferramentas PEP 517/518
├── requirements.txt            # Dependências de execução
├── Makefile                    # Atalhos para desenvolvedores
├── VERSION                     # Fonte única da verdade da versão
├── CHANGELOG.md
├── SECURITY.md
├── .github/
│   └── workflows/ci.yml        # GitHub Actions: lint + matriz de testes + mypy
├── docker/
│   ├── Dockerfile
│   └── docker-compose.yml
├── credattack/
│   ├── cli.py                  # CLI (Typer) — empacotada, dá suporte ao script de console
│   ├── core/
│   │   ├── config.py           # Configurações Pydantic v2
│   │   ├── engine.py           # AttackEngine (ThreadPoolExecutor)
│   │   ├── lockout.py          # LockoutDetector (janela deslizante)
│   │   ├── proxy.py            # ProxyRotator
│   │   ├── mutator.py          # PasswordMutator
│   │   ├── result.py           # AttemptResult, SessionReport
│   │   ├── report.py           # Gerador de relatórios HTML
│   │   └── logger.py           # Logger Rich + gravador JSONL
│   ├── protocols/              # 18 implementações de ProtocolAttacker
│   │   └── base.py             # ProtocolAttacker abstrato
│   └── data/
│       ├── default_creds.json  # 200+ padrões de fornecedores
│       ├── smart_patterns.json # 140+ modelos empresariais
│       └── wordlists/          # Listas iniciais por serviço
├── attacks/                    # Ferramentas autônomas de arquivo único (anteriores ao credattack/;
│   └── *.py                    # mantidas para scripts ainda não portados: quebra de JWT,
│                                # detecção de WAF, enumeração de usuários baseada em tempo)
├── utils/
│   └── credential_utils.py     # Helpers compartilhados para os scripts de attacks/
├── tests/
│   ├── conftest.py             # Fixtures compartilhadas
│   ├── test_lockout.py
│   ├── test_mutator.py
│   ├── test_mutator_extended.py
│   ├── test_proxy.py
│   ├── test_result.py
│   ├── test_protocols_ssh.py
│   ├── test_protocols_ftp.py
│   └── test_protocols_http.py
├── wordlists/                  # Stubs mínimos de smoke-test
└── output/                     # Logs e relatórios gerados (ignorados pelo git)
```

---

## Taxas de Sucesso de Ataque (Indicativas)

| Tipo de Senha | Dicionário | Modo Inteligente | Spray (comum) |
|---------------|-----------|------------|----------------|
| 4 caracteres | ~90% | ~95% | ~60% |
| 6 caracteres | ~65% | ~75% | ~25% |
| 8 caracteres mistos | ~15% | ~25% | ~5% |
| 10+ caracteres complexos | <5% | <5% | <1% |

---

## Contribuição

Consulte [CONTRIBUTING.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/CONTRIBUTING.md).  
Abra uma issue antes de enviar PRs grandes.  
Todas as contribuições devem aderir à política de uso ético em [SECURITY.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/SECURITY.md).

---

**Use com responsabilidade. Teste com ética. Permaneça dentro da lei.**
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    589
  • 3

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    361
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    339
  • 5

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    324
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    322

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →