chiunque può spiegare attacchi basati su SQL in errore

Question

chiunque può spiegare attacchi basati su SQL in errore

#1 da (2 voti)
#2 da (1 voti)
#3 da (1 voti)

2

Pratico per l'injection sql basato sull'errore, ma non c'è alcun riferimento valido per questo.

per esempio :):

mysql> select count(*),floor(rand()*2) as a from users group by a;
ERROR 1062 (23000): Duplicate entry '0' for key 'group_key'
mysql> select count(*),floor(rand()*2) as a from users group by a;
ERROR 1062 (23000): Duplicate entry '1' for key 'group_key'
mysql> select count(*),floor(rand()*2) as a from users group by a;
+----------+---+
| count(*) | a |
+----------+---+
|       10 | 0 |
|        3 | 1 |
+----------+---+
2 rows in set (0.00 sec)

perché la prima e la seconda query non vengono eseguite?

significa il valore della prima o della seconda riga di pari con una colonna?

quindi, perché quando cambio la query non riesco a vedere alcun messaggio di errore:

mysql> select 1,floor(rand()*2) as a from users group by a;

+---+---+
| 1 | a |
+---+---+
| 1 | 0 |
| 1 | 1 |
+---+---+
2 rows in set (0.00 sec)

Non posso sottostimare la vulnerabilità di sql injection basata sull'errore e vedo anche questo link: link ma ho ancora una domanda!

Come si verifica questa vulnerabilità?

Grazie

sql-injection mysql

posta unbl0ck3r 21.06.2015 - 22:53

fonte

3 risposte

2

L'injection sql basato sull'errore sfrutta la scarsa gestione degli errori in un'applicazione.

Quando l'applicazione restituisce l'errore mysql, trovi un modo (di solito è con group by) di avere i dati interessanti restituiti da mysql nell'errore.

Nel tuo esempio non riesco a vedere quali informazioni stai cercando di ottenere ma guardi questo sito, ci sono buoni esempi lì.

Come puoi vedere negli esempi, ogni richiesta è fatta per innescare un errore. Questo errore conterrà il valore desiderato dall'attaccante. Ad esempio, la versione mysql verrà recuperata con l'errore "Duplicate entry" versione di MySQL qui "per la chiave 1".

risposta data 22.06.2015 - 00:34

fonte

1

L'iniezione SQL basata sull'errore è utile quando si dispone di una pagina che esegue una query in cui l'output non è mostrato, ma verrà visualizzato un errore del database se ce n'è uno. Anche se puoi sfruttare questo errore utilizzando SQLi cieco, l'errore basato su offre un aumento significativo della velocità.

Lo sfruttamento si basa sull'iniezione di una condizione che causerà un errore, il tipo di trasmissione è spesso usato:

select 0+@@version
select @@version/0

Sebbene sia possibile utilizzare qualsiasi errore, è importante valutare i dati che si desidera estrarre, quindi non è possibile utilizzare un errore di sintassi.

Spero che questo ti aiuti a capire come funziona SQLi basato sull'errore.

risposta data 22.06.2015 - 00:39

fonte

Leggi altre domande sui tag sql-injection mysql

Server compromesso con la vulnerabilità di magento, possibile rootkit Come decodificare .dmg con BruteForce [chiuso]

score 1 · Accepted Answer

La vulnerabilità è SQL Injection. Basato sull'errore è solo un metodo per rendere il messaggio di errore Mostra dati desiderati rispetto all'errore, per quando abbiamo una vulnerabilità cieca che mostra un errore, quindi possiamo estrarre dati sensibili dal database direttamente (invece di un bit alla volta).

Quindi come funziona la query?

select count(*),concat_ws(0x3a,database(),floor(rand()*2)) as a from users group by a

Per prima cosa, abbiamo bisogno di count(*) perché vogliamo che il database esegua effettivamente l'operazione di aggregazione (di gruppo) e non la ottimizzi.

In secondo luogo, utilizziamo concat_ws(0x3a solo per rendere le cose più belle. Possiamo solo utilizzare concat(DESIRED_DATA,floor(rand()*2)) .

Ok, ora passiamo alla logica. concat(DESIRED_DATA,floor(rand()*2)) ti darà risultati diversi in base a ciascuna riga del risultato del database, perché è così che funziona rand() . Fornisce un numero casuale compreso tra 0 e 1 per ogni riga di output. Ora dal momento che il nostro random è limitato a {0,1}, genera solo due valori. Se questi due valori sono diversi (ad esempio, 0 e 1), la query viene eseguita correttamente e ti fornisce l'output che hai visto sopra.

Tuttavia, se entrambi danno lo stesso numero, allora group by fallirà, perché il group_key che ci si aspettava fosse univoco (è l'ID della tabella dei risultati temporanea) sarà duplicato e causerà il database errare.

Ora, a Mysql piace dire quale sia esattamente il valore duplicato in quella query, quindi mostra la chiave duplicata, che sarà la DESIRED_DATA concatenata da 1 o 0 (da qui il 0x31 per separarli meglio).

Quindi le due parti di trucco, count(*) e rand() sono entrambe necessarie in modo che MySQL lo esegua più volte, invece di limitarsi a ottimizzarlo. Ma il trucco è creare una tabella temporanea con chiavi duplicate e lasciare che MySQL ci dica del valore di quella chiave in un errore .