Verificare Vulnerabilità

Per verificare la presenza di vulnerabilità SQL Injection, è possibile testare i campi di input con una serie di caratteri e operatori particolari che potrebbero rivelare errori di sintassi o comportamenti anomali nel database.
Tra i metodi più utilizzati ci sono i test con apici singoli e operatori booleani, che possono evidenziare se il sistema è vulnerabile ad attacchi SQL Injection.

Test con Apici Singoli

L'apostrofo (`'`) è uno dei caratteri più comuni usati per verificare la presenza di SQL Injection, poiché può causare un errore SQL se non gestito correttamente. Ecco come funziona:

Inserire un Apostrofo nei Campi di Input

Provare ad aggiungere un `'` come valore di un campo, ad esempio in una barra di ricerca, in un campo di login o nell'URL stesso, come in `?id=1'`.

Osservare la Risposta del Server

Se il server restituisce un errore come `Syntax error`, `Unterminated string`, o altre informazioni di SQL, potrebbe indicare una vulnerabilità.
Un errore di questo tipo significa che il codice SQL del backend non è stato in grado di gestire correttamente l'apice, mostrando che l'applicazione non ha sanitizzato l'input.
Esempio:

   
   SELECT * FROM prodotti WHERE nome = 'apice'';
   
   

Questo genererà un errore perché l'apice singolo finale chiude prematuramente la stringa.

Tentare con Doppio Apostrofo

Se il singolo `'` non causa errori, potrebbe essere utile provare a iniettare due apici (`''`) o combinazioni diverse per cercare di interrompere la query SQL
Inserendo valori come `1' OR '1'='1` in un campo, si può tentare di manipolare la query SQL per far sì che venga sempre valutata come vera.

Test con Operatori Booleani

Gli operatori booleani, come `AND` e `OR`, sono usati per manipolare il risultato di una query. Se il campo di input non è filtrato correttamente, questi operatori possono essere usati per verificare se una SQL Injection è possibile.

Prova con "OR 1=1" o "AND 1=2"

Provare ad aggiungere espressioni booleane come `OR 1=1` (che è sempre vero) e `AND 1=2` (che è sempre falso) nei campi di input o nei parametri URL. Esempi:
- `?id=1 OR 1=1` (dovrebbe restituire tutti i risultati)
- `?id=1 AND 1=2` (dovrebbe restituire zero risultati)

Analizzare il Comportamento della Risposta

- Se il sistema restituisce tutti i risultati con `OR 1=1`, questo potrebbe indicare una vulnerabilità. Ad esempio, se il parametro `id` normalmente restituisce un solo risultato, ma con `OR 1=1` otteniamo più dati, significa che la query è stata manipolata.

- Se il sistema non restituisce risultati con `AND 1=2`, potrebbe essere un'indicazione che il campo è vulnerabile, perché la query è stata influenzata dalla condizione `AND 1=2` (che è sempre falsa).

Blind SQL Injection con Test Booleani

Quando un'applicazione non restituisce errori o messaggi di sistema visibili, è possibile utilizzare una **blind SQL Injection** con test booleani per dedurre la presenza di vulnerabilità.

Prove Booleane

- Inserire condizioni come `?id=1 AND 1=1` e verificare se il risultato è lo stesso di una normale query `?id=1`.
- Successivamente, inserire una condizione falsa come `?id=1 AND 1=2`. Se il risultato è diverso, è possibile che l'applicazione sia vulnerabile, poiché la query è stata influenzata dalla condizione booleana.

Differenze di Tempo di Risposta

Alcuni sistemi bloccano gli errori, ma un attaccante può aggiungere istruzioni come `SLEEP(n)` per vedere se il tempo di risposta cambia:
- `?id=1' AND SLEEP(5)--` (se il sistema impiega 5 secondi a rispondere, è probabile che la query sia stata modificata).

Esempi di Test e Differenze nei Risultati

Esempio di URL manipolati per verificare vulnerabilità:
- `http://example.com/prodotti.php?id=1'` → Errore di sintassi? Possibile vulnerabilità.
- `http://example.com/prodotti.php?id=1 OR 1=1` → Restituisce più dati? Potenziale vulnerabilità.
- `http://example.com/prodotti.php?id=1 AND 1=2` → Nessun dato restituito? Conferma della vulnerabilità.
- `http://example.com/prodotti.php?id=1' AND SLEEP(5)--` → Risposta ritardata? Vulnerabilità potenziale.

Considerazioni Finali

Per verificare correttamente una vulnerabilità SQL Injection:
- Usare test con apici singoli per generare errori SQL.
- Utilizzare operatori booleani per verificare la manipolazione delle query.
- Analizzare con attenzione la risposta del server, osservando differenze nei risultati o nei tempi di risposta.

Importante

Effettuare Solo Test Autorizzati
Questi test vanno effettuati solo in ambienti di sviluppo, o previa autorizzazione, per evitare violazioni di sicurezza e conseguenze legali.