Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
credential-attacks-toolkit — Suite completa di attacchi alle credenziali per test di sicurezza autorizzati — SSH, FTP, Web Login, Bruteforce, Dictionary attacks | Kitploit
Strumenti/GitHubGitHub/amibhai/credential-attacks-toolkit
RicognizioneAttacchi alle PasswordPenetration TestingRed Teaming
GitHubamibhai/credential-attacks-toolkit

credential-attacks-toolkit

Suite completa di attacchi alle credenziali per test di sicurezza autorizzati — SSH, FTP, Web Login, Bruteforce, Dictionary attacks

Vedi Repository
Condividi
1653 mesi faNon ancora revisionato
# CredAttack — Toolkit per Attacchi alle Credenziali

<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>

> **⚠️ AVVISO LEGALE — Solo test di sicurezza AUTORIZZATI.**  
> L'uso di questo strumento contro sistemi di cui non si è proprietari o per i quali non si dispone di **esplicita autorizzazione scritta** è illegale ai sensi del Computer Fraud and Abuse Act (USA), del Computer Misuse Act (UK) e delle leggi equivalenti in tutto il mondo. Vedi [SECURITY.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/SECURITY.md).

---

## Indice

- [Cos'è CredAttack?](#cosè-credattack)
- [Modalità di Attacco](#modalità-di-attacco)
- [Protocolli Supportati](#protocolli-supportati)
- [Architettura](#architettura)
- [Avvio Rapido](#avvio-rapido)
- [Installazione](#installazione)
- [Riferimento CLI](#riferimento-cli)
- [Motore di Mutazione delle Password](#motore-di-mutazione-delle-password)
- [Database delle Credenziali Predefinite](#database-delle-credenziali-predefinite)
- [Rotazione dei Proxy](#rotazione-dei-proxy)
- [Report HTML](#report-html)
- [Configurazione e Variabili d'Ambiente](#configurazione-e-variabili-dambiente)
- [Docker](#docker)
- [Test](#test)
- [Struttura del Progetto](#struttura-del-progetto)
- [Contributi](#contributi)

---

## Cos'è CredAttack?

CredAttack è una **suite di test delle credenziali modulare e di livello produttivo** per test di penetrazione autorizzati. Copre l'intero ciclo di vita dell'attacco alle credenziali:

| Fase | Capacità di CredAttack |
|-------|-----------------------|
| **Ricognizione** | Database credenziali predefinite (200+ coppie), generazione intelligente di pattern derivati dal nome utente |
| **Attacco** | 17 attacker per protocollo, 6 modalità di attacco, campagne multi-target |
| **Evasione** | Rilevamento lockout, limitazione della velocità configurabile, jitter, rotazione dei proxy |
| **Reporting** | Log di audit JSONL, report HTML Jinja2, banner credenziali trovate + dump su file |

---

## Modalità di Attacco

| Modalità | Comando | Descrizione |
|------|---------|-------------|
| **Dizionario** | `ssh`, `ftp`, `smb`, … | Wordlist contro un singolo utente |
| **Spray** | `spray` | Una password su una lista di utenti (sicuro contro lockout) |
| **Combo** | `combo` | Ogni utente × ogni password |
| **Smart** | `smart` | Generazione di pattern derivati da nome utente/azienda |
| **Predefinite** | `defaults` | Prova oltre 200 credenziali predefinite note dei servizi |
| **Multi-target** | `multi` | Stesso attacco su una lista di host |
| **Pipeline completo** | `full` | Tutti i protocolli, un unico report |

---

## Protocolli Supportati

| # | Protocollo | Modulo | Porta Predefinita | Note |
|---|----------|--------|-------------|-------|
| 1 | SSH | `ssh.py` | 22 | paramiko, autenticazione chiave/password |
| 2 | FTP | `ftp.py` | 21 | Modalità attiva e passiva |
| 3 | HTTP Form | `http_form.py` | 80/443 | Rilevamento automatico 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 | Supporto 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, auto-rilevamento rootDSE |
| 17 | Telnet | `telnet.py` | 23 | TCP grezzo |
| 18 | VNC | `vnc.py` | 5900 | Sfida-risposta DES grezza |

---

## Architettura

```
credattack.py          ← shim sottile: `python credattack.py ...` da un checkout
│
├── credattack/cli.py   ← CLI (Typer) — 8 sottocomandi per modalità di attacco; anche
│                          lo script console `credattack` quando installato via pip
├── credattack/core/
│   ├── config.py      ← Impostazioni Pydantic v2, override tramite variabili d'ambiente CREDATTACK_*
│   ├── engine.py      ← AttackEngine (ThreadPoolExecutor + UI di avanzamento Rich)
│   ├── lockout.py     ← LockoutDetector (finestra scorrevole, thread-safe)
│   ├── proxy.py       ← ProxyRotator (round-robin, health-check, declassamento)
│   ├── mutator.py     ← PasswordMutator (leet, stagionale, suffisso, keyboard-walk…)
│   ├── result.py      ← Dataclass AttemptResult + SessionReport
│   ├── report.py      ← Generatore di report HTML Jinja2
│   └── logger.py      ← Logging Rich + writer di audit JSONL
│
├── credattack/protocols/
│   └── *.py           ← 18 implementazioni ProtocolAttacker
│
├── credattack/data/
│   ├── default_creds.json    ← 200+ coppie reali di credenziali predefinite
│   ├── smart_patterns.json   ← 140+ modelli di password aziendali
│   └── wordlists/            ← Liste di password predefinite per servizio
│
└── tests/             ← 50+ test pytest (unit + mock dei protocolli)
```

---

## Avvio Rapido

```bash
# Clona e configura
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

# Controlla la versione
python credattack.py --version

# Dry-run (nessuna connessione effettuata — verifica le tue wordlist)
python credattack.py ssh -t 192.168.1.100 -u admin -P wordlists/common_passwords.txt --dry-run

# Attacco SSH a dizionario reale
python credattack.py ssh -t 192.168.1.100 -u admin -P /path/to/rockyou.txt

# Password spray (con limitazione di velocità, sicuro contro lockout)
python credattack.py spray -t 192.168.1.100 --protocol ssh -U users.txt -p "Summer2024!" --delay 30

# Modalità smart — genera pattern da nome utente + azienda
python credattack.py smart -t 192.168.1.100 --protocol ssh -u john.doe --company ACME

# Prova le credenziali predefinite dei servizi
python credattack.py defaults -t 192.168.1.100 --protocol mysql

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

---

## Installazione

### Opzione A — pip + virtualenv (consigliata)

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

### Opzione B — Scorciatoie Makefile

```bash
make install      # dipendenze core
make install-dev  # + pytest-cov, ruff, mypy
```

### Opzione C — pip install (editable o da wheel)

```bash
pip install -e .          # solo dipendenze core
pip install -e .[full]    # + SMB/RDP/MySQL/MSSQL/Redis/MongoDB/WinRM/LDAP
pip install -e .[dev]     # + pytest/ruff/mypy

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

### Opzione D — Docker

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

# Monta le tue wordlist e raccogli l'output
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
```

---

## Riferimento CLI

### Opzioni globali

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

Options:
  -V, --version    Mostra la versione ed esce.
  --help           Mostra l'aiuto.
```

### Flag comuni (disponibili su tutti i comandi dei protocolli)

| Flag | Short | Predefinito | Descrizione |
|------|-------|---------|-------------|
| `--target` | `-t` | — | Host / IP di destinazione |
| `--port` | | 0 (predefinito del protocollo) | Sovrascrive la porta TCP |
| `--username` | `-u` | — | Nome utente singolo |
| `--user-file` | `-U` | — | File dei nomi utente separati da nuova riga |
| `--pass-file` | `-P` | — | File delle password separate da nuova riga |
| `--password` | `-p2` | — | Password singola |
| `--threads` | `-n` | 10 | Worker concorrenti |
| `--timeout` | `-T` | 5.0 | Timeout per tentativo (s) |
| `--delay` | `-d` | 0.0 | Ritardo fisso tra i tentativi (s) |
| `--jitter` | | 0.0 | Jitter casuale massimo (s) |
| `--stop-on-first` | | True | Ferma per utente dopo il primo successo |
| `--proxy-file` | | None | Lista proxy HTTP/SOCKS5 |
| `--output-dir` | `-o` | `./output` | Directory dei risultati |
| `--verbosity` | `-v` | 1 | Livello di logging (0-3) |
| `--dry-run` | | False | Conta le coppie senza connettersi |

### Sottocomandi

```bash
# Specifici per protocollo (ognuno mappa a un attacker dedicato)
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 (form / basic / digest)
python credattack.py http -t http://target/login --mode form \
  --form-user-field username --form-pass-field password --success-string "Dashboard"

# Spray — password singola, molti utenti, ritardo lungo
python credattack.py spray -t HOST --protocol ssh -U users.txt -p "Password1" --delay 30

# Combo — prodotto cartesiano utenti × password
python credattack.py combo -t HOST --protocol smb -U users.txt -P passes.txt

# Smart — generazione derivata da OSINT
python credattack.py smart -t HOST --protocol ssh -u firstname.lastname --company TargetCorp

# Defaults — prova le credenziali predefinite del vendor
python credattack.py defaults -t HOST --protocol mysql

# Multi — stesso attacco su più host
python credattack.py multi --targets hosts.txt --protocol ssh -U users.txt -P passes.txt

# Full — tutti i protocolli in sequenza
python credattack.py full -t HOST -U users.txt -P passes.txt
```

---

## Motore di Mutazione delle Password

`PasswordMutator` in `credattack/core/mutator.py` supporta strategie componibili:

| Strategia | Metodo | Esempio di output |
|----------|--------|----------------|
| Leet-speak | `leet_speak(word)` | `p@ssw0rd`, `p455w0rd` |
| Capitalizzazione | `capitalise_variants(word)` | `PASSWORD`, `Password`, `pAsSwOrD` |
| Suffisso | `suffix_append(word)` | `password123`, `password@2025` |
| Prefisso | `prefix_append(word)` | `!password`, `mypassword` |
| Keyboard-walk | `keyboard_walk(word)` | `qassword` (a→q) |
| Pattern nome utente | `username_patterns(user, company)` | `john123`, `Doe1!`, `ACME2024!` |
| **Stagionale** (v1.1) | `seasonal_patterns(company)` | `Summer2024!`, `Winter25` |
| **Avvolgimento caratteri speciali** (v1.1) | `special_char_wrap(word)` | `!@Password`, `Password!@` |
| Combina | `combine(word, strategies)` | concatena qualsiasi delle precedenti |
| Smart (tutto-in-uno) | `smart_generate(user, company)` | stream deduplicato e limitato |

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

m = PasswordMutator(max_mutations=5000)

# Tutte le strategie combinate
for pw in m.smart_generate("john.doe", company="ACME"):
    print(pw)

# Solo pattern stagionali
for pw in m.seasonal_patterns(company="Contoso"):
    print(pw)
```

---

## Database delle Credenziali Predefinite

`credattack/data/default_creds.json` contiene **200+ coppie reali di credenziali predefinite** tra:

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
# Visualizza tutte le predefinite per un servizio
python credattack.py defaults -t HOST --protocol mysql --dry-run

# Esegui contro il target
python credattack.py defaults -t 10.0.0.1 --protocol ssh
```

---

## Rotazione dei Proxy

Passa un file di proxy (un proxy per riga, 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
```

Il `ProxyRotator` esegue health-check all'avvio e declassa i proxy che superano una soglia di tasso di errore. I proxy morti vengono esclusi automaticamente.

---

## Report HTML

Dopo ogni attacco non-dry-run viene generato automaticamente un report HTML in `./output/`:

- **Card statistiche**: tentativi totali, tasso di successo, durata, tentativi/sec
- **Tabella credenziali trovate**: host · protocollo · nome utente · password (copia-negli-appunti)
- **Tema scuro** modello Jinja2

```bash
# Apri dopo un'esecuzione
start output/report_*.html      # Windows
open  output/report_*.html      # macOS
```

---

## Configurazione e Variabili d'Ambiente

Tutte le impostazioni in `credattack/core/config.py` possono essere sovrascritte tramite variabili d'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
```

Oppure a livello CLI con i flag standard (`--threads`, `--timeout`, ecc.).

---

## Docker

```bash
# Costruisci l'immagine
docker build -t credattack -f docker/Dockerfile .

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

# Imposta la configurazione tramite variabili d'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
```

---

## Test

```bash
# Esegui tutti i test
pytest -q

# Con copertura
pytest --cov=credattack --cov-report=term-missing -q

# Scorciatoia Makefile
make test-cov
```

**Suite attuale: 50+ test** che coprono:

| Area | Test |
|------|-------|
| Rilevatore lockout (finestra scorrevole, thread safety) | `test_lockout.py` |
| Strategie del mutatore di password | `test_mutator.py` |
| Nuove strategie del mutatore (stagionale, caratteri speciali) | `test_mutator_extended.py` |
| Rotatore proxy (health-check, declassamento) | `test_proxy.py` |
| Dataclass Result e SessionReport | `test_result.py` |
| Mock protocollo SSH | `test_protocols_ssh.py` |
| Mock protocollo FTP | `test_protocols_ftp.py` |
| Mock HTTP Basic e Digest | `test_protocols_http.py` |

---

## Wordlist

> **⚠️ I file `wordlists/` inclusi sono stub minimi per smoke-test.** Fornisci le tue per valutazioni reali.

### Fonti consigliate

| Wordlist | Dimensione | Ideale Per |
|----------|------|----------|
| `rockyou.txt` | ~14 M | Dizionario generale |
| `SecLists/Passwords/` | Varie | Specifiche per protocollo |
| `kaonashi.txt` | ~64 M | Copertura avanzata |
| Derivata da OSINT | Variabile | Attacchi mirati |

```bash
# Usa qualsiasi wordlist esterna
python credattack.py ssh -t TARGET -u admin -P /opt/wordlists/rockyou.txt
```

---

## Struttura del Progetto

```
credential-attacks-toolkit/
├── credattack.py               # Shim sottile -> credattack.cli:app (uso da checkout sorgente)
├── pyproject.toml              # Configurazione build e strumenti PEP 517/518
├── requirements.txt            # Dipendenze runtime
├── Makefile                    # Scorciatoie per sviluppatori
├── VERSION                     # Unica fonte di verità per la versione
├── CHANGELOG.md
├── SECURITY.md
├── .github/
│   └── workflows/ci.yml        # GitHub Actions: lint + matrice di test + mypy
├── docker/
│   ├── Dockerfile
│   └── docker-compose.yml
├── credattack/
│   ├── cli.py                  # CLI (Typer) — pacchettizzata, supporta lo script console
│   ├── core/
│   │   ├── config.py           # Impostazioni Pydantic v2
│   │   ├── engine.py           # AttackEngine (ThreadPoolExecutor)
│   │   ├── lockout.py          # LockoutDetector (finestra scorrevole)
│   │   ├── proxy.py            # ProxyRotator
│   │   ├── mutator.py          # PasswordMutator
│   │   ├── result.py           # AttemptResult, SessionReport
│   │   ├── report.py           # Generatore di report HTML
│   │   └── logger.py           # Logger Rich + writer JSONL
│   ├── protocols/              # 18 implementazioni ProtocolAttacker
│   │   └── base.py             # ProtocolAttacker astratto
│   └── data/
│       ├── default_creds.json  # 200+ predefinite dei vendor
│       ├── smart_patterns.json # 140+ modelli aziendali
│       └── wordlists/          # Liste iniziali per servizio
├── attacks/                    # Strumenti autonomi a file singolo (precedono credattack/;
│   └── *.py                    # mantenuti per script non ancora migrati: cracking JWT,
│                                # rilevamento WAF, enumerazione utenti basata su timing)
├── utils/
│   └── credential_utils.py     # Helper condivisi per gli script attacks/
├── tests/
│   ├── conftest.py             # Fixture condivise
│   ├── 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/                  # Stub minimi per smoke-test
└── output/                     # Log e report generati (ignorati da git)
```

---

## Tassi di Successo degli Attacchi (Indicativi)

| Tipo di Password | Dizionario | Modalità Smart | Spray (comune) |
|---------------|-----------|------------|----------------|
| 4 caratteri | ~90% | ~95% | ~60% |
| 6 caratteri | ~65% | ~75% | ~25% |
| 8 caratteri misti | ~15% | ~25% | ~5% |
| 10+ caratteri complessi | <5% | <5% | <1% |

---

## Contributi

Vedi [CONTRIBUTING.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/CONTRIBUTING.md).  
Apri una issue prima di inviare PR di grandi dimensioni.  
Tutti i contributi devono rispettare la policy di uso etico in [SECURITY.md](https://github.com/amibhai/credential-attacks-toolkit/blob/main/SECURITY.md).

---

**Usa in modo responsabile. Testa eticamente. Rispetta la legge.**
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    589
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    361
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    339
  • 5

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    324
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    322

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →