Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
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.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
MAD-CAT — MAD-CAT (Meow Attack Data Corruption Automation Tool) è uno strumento di sicurezza completo progettato per simulare attacchi di corruzione dei dati contro molteplici sistemi di database. Lo strumento supporta sia attacchi a bersaglio singolo che campagne di attacco in massa basate su CSV, con supporto per scenari di attacco sia con credenziali che senza credenziali. | Kitploit
Strumenti/GitHubGitHub/karlvbiron/mad-cat
ExploitEsfiltrazione DatiPenetration TestingApprendimento e FormazioneRed TeamingSicurezza dei Database
GitHubkarlvbiron/mad-cat

MAD-CAT

Vedi Repository
37310 mesi faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →

Informazioni

MAD-CAT (Meow Attack Data Corruption Automation Tool) è uno strumento di sicurezza completo progettato per simulare attacchi di corruzione dei dati contro molteplici sistemi di database. Lo strumento supporta sia attacchi a bersaglio singolo che campagne di attacco in massa basate su CSV, con supporto per scenari di attacco sia con credenziali che senza credenziali.

Condividi

MAD-CAT
[Strumento di automazione della corruzione dati Meow Attack]

MAD-CAT Banner Python License

Panoramica

MAD-CAT (Meow Attack Data Corruption Automation Tool) è uno strumento di sicurezza completo progettato per simulare attacchi di corruzione dei dati su più sistemi di database. Lo strumento supporta sia attacchi a bersaglio singolo che campagne di attacco di massa basate su file CSV, con supporto per scenari di attacco con e senza credenziali.

Servizi di database supportati

Lo strumento attualmente supporta i seguenti servizi di database:

MongoDB Elasticsearch Cassandra
Redis
CouchDB
Hadoop
  • MongoDB (porta 27017)
  • Elasticsearch (porta 9200)
  • Cassandra (porta 9042)
  • Redis (porta 6379)
  • CouchDB (porta 5984)
  • Hadoop HDFS (porta 9870)

Installazione

root@kitploit:~
# Clone the repository
git clone https://github.com/karlvbiron/MAD-CAT.git

# Navigate to the tool directory
cd MAD-CAT

# Set up the virtual environment
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -r requirements.txt

Argomenti della riga di comando

ArgumentDescription
-l, --listElenca i servizi di database supportati
-c, --csvFile CSV contenente l'elenco dei bersagli (formato: ip,service,port,username,password)
-t, --targetIndirizzo IP del host bersaglio (per la modalità bersaglio singolo)
-s, --serviceServizio di database da attaccare (es. mongodb, elasticsearch, cassandra, redis, couchdb, hadoop)
-p, --portNumero di porta (se non predefinita)
-u, --usernameNome utente per l'autenticazione
-pw, --passwordPassword per l'autenticazione
-v, --verboseAbilita l'output dettagliato

Esempi di utilizzo

Elenca i servizi supportati

root@kitploit:~
python mad_cat.py -l

Attacchi a bersaglio singolo

Simulazione MongoDB (con credenziali)

root@kitploit:~
python mad_cat.py -t 192.168.1.11 -s mongodb -u root -pw example

Simulazione Elasticsearch (senza credenziali)

root@kitploit:~
python mad_cat.py -t 192.168.1.12 -s elasticsearch

Simulazione Cassandra

root@kitploit:~
python mad_cat.py -t 192.168.1.13 -s cassandra

Simulazione Redis

root@kitploit:~
python mad_cat.py -t 192.168.1.14 -s redis

Simulazione CouchDB (con credenziali)

root@kitploit:~
python mad_cat.py -t 192.168.1.15 -s couchdb -u admin -pw password

Simulazione Hadoop HDFS

root@kitploit:~
python mad_cat.py -t 192.168.1.16 -s hadoop

Modalità di attacco bulk con CSV

Attacca più bersagli utilizzando un file CSV:

root@kitploit:~
python mad_cat.py -c list.csv

Formato del file CSV

Il file CSV deve contenere un bersaglio per riga con il seguente formato:

root@kitploit:~
192.168.1.11,mongodb,27017,"root","example"
192.168.1.12,elasticsearch,9200,"",""
192.168.1.13,cassandra,9042,"",""
192.168.1.14,redis,6379,"",""
192.168.1.15,couchdb,5984,"admin","password"
192.168.1.16,hadoop,9870,"",""

Formato: ip,service,port,username,password

  • Lascia nome utente/password come stringhe vuote ("") per attacchi senza credenziali

Struttura del progetto

root@kitploit:~
MAD-CAT/
├── __init__.py
├── core/
│   ├── __init__.py
│   ├── base_attacker.py          # Abstract base class for all attackers
│   └── attack_factory.py         # Factory pattern for attacker creation
├── attackers/
│   ├── __init__.py               # Attacker registration
│   ├── mongodb.py                # MongoDB attacker implementation
│   ├── elasticsearch.py          # Elasticsearch attacker implementation
│   ├── cassandra.py              # Cassandra attacker implementation
│   ├── redis.py                  # Redis attacker implementation
│   ├── couchdb.py                # CouchDB attacker implementation
│   └── hadoop.py                 # Hadoop HDFS attacker implementation
├── utils/
│   ├── __init__.py
│   └── logging.py                # Logging configuration
├── dockerized-database-infrastructure/
│   ├── docker-compose.yml        # Docker Compose configuration
│   └── init-scripts/
│       ├── mongodb/
│       │   └── mongodb-init.js
│       ├── elasticsearch/
│       │   ├── es-custom-entrypoint.sh
│       │   └── es-bulk_data.json
│       ├── cassandra/
│       │   ├── cassandra-entrypoint.sh
│       │   └── cassandra-init.cql
│       ├── couchdb/
│       │   ├── couchdb-entrypoint.sh
│       │   └── couchdb-init.sh
│       ├── hadoop/
│       │   ├── hadoop-entrypoint.sh
│       │   └── hadoop-init.sh
│       └── redis/
│           ├── redis-entrypoint.sh
│           └── redis-init.sh
├── mad_cat.py                    # Main entry point
├── fetch_data.py                 # Utility to fetch and verify database data
├── list.csv                      # Example CSV file for bulk attacks
├── requirements.txt              # Python dependencies
└── README.md                     # This file

Caratteristiche

  • ✅ 6 servizi di database: MongoDB, Elasticsearch, Cassandra, Redis, CouchDB, Hadoop HDFS
  • ✅ Attacchi con e senza credenziali: supporta entrambe le modalità di autenticazione
  • ✅ Modalità bersaglio singolo: attacca singole istanze di database
  • ✅ Modalità attacco bulk via CSV: attacca più bersagli da un file CSV
  • ✅ Architettura a pattern Factory: facile da estendere con nuovi attaccanti per database
  • ✅ Registrazione completa: log con timestamp salvati nella directory logs/
  • ✅ Conferma utente: richiede conferma esplicita prima di eseguire gli attacchi
  • ✅ Statistiche di attacco: report dettagliati di database, collezioni e record interessati
  • ✅ Supporto porte predefinite: utilizza automaticamente le porte standard se non specificate

Come funziona

MAD-CAT simula un attacco di corruzione dei dati:

  1. Connessione al database bersaglio utilizzando le credenziali fornite (o tentando accesso anonimo)
  2. Enumerazione di tutti i database e le collezioni/tabelle (esclusi i database di sistema)
  3. Corruzione dei dati sostituendo stringhe/valori numerici con stringhe alfanumeriche casuali seguite da "-MEOW"
  4. Report con statistiche sui database elaborati, collezioni interessate e record modificati

Workflow dell'attacco

root@kitploit:~
Target → Connect → List Databases → For Each Database:
                                      ├─ List Collections
                                      └─ For Each Collection:
                                          ├─ Fetch All Records
                                          ├─ Replace Values with {random}-MEOW
                                          └─ Update Records

Porte predefinite

ServizioPorta predefinita
MongoDB27017
Elasticsearch9200
Cassandra9042
Redis6379
CouchDB5984
Hadoop HDFS9870

Strumenti aggiuntivi

fetch_data.py

Uno script di utilità per recuperare e visualizzare i dati da tutti i database supportati:

root@kitploit:~
# Fetch from all databases and verify consistency
python fetch_data.py all

# Fetch from specific database
python fetch_data.py mongo
python fetch_data.py elasticsearch
python fetch_data.py cassandra
python fetch_data.py redis
python fetch_data.py couchdb
python fetch_data.py hadoop

Dichiarazione di esclusione di responsabilità

Questo strumento è fornito SOLO A SCOPO EDUCATIVO. È progettato per dimostrare un tipo di attacco informatico in un ambiente controllato per aiutare a migliorare la consapevolezza sulla sicurezza e le misure difensive. L'uso di questo strumento contro sistemi senza la dovuta autorizzazione è illegale e contrario all'etica. Gli autori e i collaboratori non sono responsabili di qualsiasi uso improprio di questo software.

Licenza

Questo progetto è concesso in licenza sotto la Licenza MIT - vedere il file LICENSE per i dettagli.

Autore

Creato da Karl Biron

Scarica lo strumento