Y hablando de XXE...Windows Remote Assistance XXE Vulnerability!

Hola a todos. Hace pocos días fué publicada una vulnerabilidad de XXE relacionada a una funcionalidad de Windows. Esto nos viene como anillo al dedo para continuar con el tema de la entrada anterior

El 20/03, el investigador Nabeel Ahmed publicó  una vulnerabilidad de XXE que afecta a la funcionalidad Windows Remote Assistance (CVE-2018-0878).

Qué es Windows Remote Assistance?

Es una herramienta que nos permite darle el control remoto de nuestro equipo a alguien para que nos ayude a solucionar un problema (Esto ya suena bastante feo). Su funcionamiento es el siguiente.

Se ejecuta remote assistance y nos aparece la siguiente ventana:

Si elegimos la opción "Invitar a una persona de confianza para ayudarle" nos pedirá que especifiquemos como queremos invitar a nuestro asistente/ayudante. Esto puede hacerse de tres maneras:

1. Guardar la información en un archivo
2. Usar el correo para enviar la invitación
3. Usar conexión fácil (fácil siempre significa poco seguro jeje)

Si seleccionamos "Guardar esta invitación como un archivo" se nos genera el  archivo de invitación (como era de esperar):

Este archivo contiene la siguiente información:

Contenido del archivo de invitación

Como podemos observar, es un archivo XML con los siguientes parámetros:

Parámetros del archivo de invitación

Conocer o no estos parámetros no nos interesan para explotar la vulnerabilidad asi que no ahondaremos mas en ellos.

El problema está, en la librería utilizada por Windows para parsear el contenido del archivo de invitación. Si listamos las dll´s cargadas para el proceso de asistencia remota veremos una llamada msxml3.dll

Librería que se encarga de parsear la info

Esta librería permite el uso de SYSTEM entities, de lo cual podemos abusar como vimos en la entrada anterior....

Preparando nuestro ataque

Lo que vamos a hacer para poder obtener información del equipo víctima, es modificar el archivo de invitación. Lo que vamos a colocar en el archivo es algo similar a lo que vimos y explicamos en la entrada anterior:

Contenido del archivo de invitación modificado

Básicamente, le pedimos al equipo víctima que se conecte a nuestro equipo (donde tenedremos un web server escuchando en el puerto 80) y que lea un archivo xml con la siguiente información:

Archivo alojado en nuestro servidor con instrucciones para leer el archivo win.ini

En esta demostración, como habrán podido notar, está todo realizado desde el mismo host, pero con esto alcanza para demostrar la vulnerabilidad. 

Con todo esto listo, enviamos el archivo a nuestra víctima. Una vez que lee el archivo,  el parser hace su trabajo, busca el contenido del archivo win.ini que le especificamos y lo envía a nuestro servidor.

Aquí, lo que vemos en el access log de nuestro Apache:

Nice no?

Microsoft ya publicó un update de seguridad para mitigar esto asi que...a parchear!

https://support.microsoft.com/en-us/help/4089453/security-update-for-vulnerabilities-in-windows-server-2008

Les dejo el enlace al blog de la publicación de la vulnerabilidad:

https://krbtgt.pw/windows-remote-assistance-xxe-vulnerability/

SALUDOS Y....

HAPPY XXE HACKING!

Android Hacking Series - Parte II (obteniendo el patrón de bloqueo)

Siguiendo con las "Android Hacking Series", en esta entrada veremos como obtener el patrón de bloqueo de un Android rooteado. Como no podía ser de otra manera, nos ayudaremos de un pequeño script hecho en python :)

Para comenzar debemos tener en cuenta lo siguiente:

Cada punto del patrón tiene asignado un número, como vemos en la imagen. Esto quiere decir que cuando generamos un patrón, estamos generando un código.

Ese patrón, teniendo en cuenta lo dicho, nos genera el código: 0 1 4 7 5 2

Este código se encuentra guardado dentro de la ruta /data/system , en un archivo llamado gesture.key. Este archivo debemos leerlo con algún programa que lea en hexa porque sino veremos los caracteres con otra codificación y no tendrán sentido.

Utilizando algun emulador de consola de Android o adb, copiamos el archivo gesture.key a una ubicación que podamos leer. Yo lo voy a copiar a la tarjeta sd (si no se entiende muy bien no se preocupen, está explicado en el video de mas abajo).

El archivo se encuentra cifrado con el algoritmo SHA-1 con lo cual debemos desencriptarlo. Para hacer esto utilizaremos la siguiente tabla de hashes precalculados:

http://www.android-forensics.com/tools/AndroidGestureSHA1.rar

Lo que haremos será comparar cada valor de la tabla con el valor obtenido del archivo gesture.key, hasta encontrar una coincidencia.

Para ello utilizaremos un pequeño script en python que desarrolle para esta ocasión el cual realiza lo siguiente:

1 - Lee el valor de gesture.key en hexa y lo imprime en pantalla
2 - Luego busca los valores en el archivo AndroidGestureSHA1.txt y los compara con el valor de gesture.key
3 - Una vez que encuentra la coincidencia, nos imprime cual es el código que corresponde a ese hash.

El código lo podemos descargar de aquí: https://sites.google.com/site/mamaquieroserpentester/home/tools

Cabe aclarar que debemos ejecutar el script en la misma carpeta que tenemos el archivo gesture.key y la lista de hashes.

Igualmente, no hace falta utilizar este script en python, yo lo armé para facilitar el proceso. Pueden realizar lo mismo utilizando un editor de texto que lea valores en hexa, como por ejemplo:

http://www.x-ways.net/winhex.zip

Y una vez obtenido el código, copiarlo y buscarlo en el listado de hashes.

Eso es todo por ahora. Les dejo el video:

Hasta la próxima, saludos y...

HAPPY HACKING!!!

Android Hacking Series - Parte I (using metasploit and taking a picture of the victim)

Hola! En esta breve entrada les dejo un video tutorial de un hacking sencillo a un Android con Metasploit. También veremos como, una vez que tenemos el control, le tomamos una foto a la víctima :)







Saludos y...



HAPPY ANDROID HACKING!!!

Armando un Port Scanner en Python!

Hola nuevamente. En esta entrada me gustaría mostrarles como crear un scanner de puertos sencillo. Como reza el título, lo haré en Python. El código se encuentra en el libro "Violent Python" , igualmente (para el que no quiera bajarse el PDF) colocaré el enlace al script al final del artículo. Para que se entienda el funcionamiento, voy a mostrar el script por porciones e iré explicando que acciones va realizando.

Para este script usaremos las librerias "optparse" y "socket"

optparse: Nos sirve para parsear opciones de línea de comando (quizás ahora suene extraño pero ya comprenderemos su funcionamiento al utilizarlo).

Warning! ---> Deprecated since version 2.7: The optparse module is deprecated and will not be developed further; development will continue with the argparsemodule. (no importa, sirve a nuestros fines jeje)

socket: Esta librería, como se imaginarán, nos permite manejar los sockets; ponerlos a la escucha, recibir, enviar,data etc.


Descripción aquí ---> http://docs.Python.org/library/socket.html

En la descripción veremos todas las funciones que posee esta librería. Las que nos interesan para nuestro port scanner son las siguientes:


socket.gethostbyname(hostname) – This function takes a hostname such
as www.google.com and returns an IPv4 address format such as
69.163.177.2.

socket.gethostbyaddr(ip address) – This function takes an IPv4 address
and returns a triple containing the hostname, alternative list of
host names, and a list of IPv4/v6 addresses for the same interface
on the host.

socket.socket([family[, type[, proto]]]) – This function creates an
instance of a new socket given the family. Options for the socket
family are AF_INET, AF_INET6, or AF_UNIX. Additionally, the socket
can be specified as SOCK_STREAM for a TCP socket or SOCK_DGRAM for
a UDP socket. Finally, the protocol number is usually zero and is
omitted in most cases.

socket.create_connection(address[, timeout[, source_address]]) – This
function takes a 2-tuple (host, port) and returns an instance of a
network socket. Additionally, it has the option of taking a timeout
and source address.

Comenzamos..

Como mencionamos arriba, utilizaremos las librerias optparse y socket, así que a darle al import:

import optparse
import   socket
from socket import *

Luego,  definimos la función que se conectará al host:

def connScan(tgtHost, tgtPort):   #definimos la función y le pasamos los parámetros 
    try:
         connSkt = socket(AF_INET, SOCK_STREAM) '''definimos la familia de socket e indicamos que es un socket TCP'''

         connSkt.connect((tgtHost, tgtPort)) #Nos conectamos al host y puerto elegidos
         connSkt.send('Hi') #Enviamos algo al destino
         results = connSkt.recv(100) #Guardamos la respuesta
         print '[+]%d/tcp open'% tgtPort
         print '[+] ' + str(results) #Mostramos los resultados
         connSkt.close()
    except:
         print '[-]%d/tcp closed'% tgtPort    '''si nos devuelve un error, mostramos en pantalla que el puerto esta cerrado'''


def portScan(tgtHost, tgtPort):  #definimos la función que escaneará el puerto
   try:
         tgtIP = gethostbyname(tgtHost) '''utilizamos la función gethostbyname para resolver el host'''
   except:
         print "[-] Cannot resolve '%s': Unknown host"%tgtHost
         return
   try:
      tgtName = gethostbyaddr(tgtIP) #Resolvemos el hostname pasandole la ip
      print '\n[+] Scan Results for: ' + tgtName[0] #Mostramos el hostname resuelto
   except:
      print '\n[+] Scan Results for: ' + tgtIP
      setdefaulttimeout(1)
   print 'Scanning port ' + str(tgtPort)
   connScan(tgtHost, int(tgtPort)) '''Llamamos a la función que se conectará para traernos el resultado open/close y luego, si está abierto el puerto realizará el banner grabbing'''

Definimos la función principal:

def main():

'''Acá esta lo que comentaba mas arriba, gracias a optparse podemos manejar mucho mejor las lineas de comando a la hora de solicitar al usuario que ingrese datos. Nos permite mostrar opciones cuando el usuario no ingresa una opción (valga la redundancia cíclica jeje) o utiliza el comando help'''

parser = optparse.OptionParser('usage %prog -H ' +  '<target host> -p <target port>')
parser.add_option('-H' , dest='tgtHost', type='string' ,  help='specify target host')
parser.add_option('-p' , dest='tgtPort', type='int' ,  help='specify target port')

(options, args) = parser.parse_args()
tgtHost=options.tgtHost
tgtPort=options.tgtPort
if (tgtHost == None) | (tgtPort==None): '''Si uno de los dos parámetros no está hacemos que vuelva a ejecutarse el script (con exit(0)), mostrando el mensaje de opciones que deben ingresarse'''
      print parser.usage
               exit(0)
        portScan(tgtHost, tgtPort)

main()

Y acá lo tenemos en acción:

Resultado al escanear el puerto 25

Resultado al escanear el puerto 80

Espero que se haya entendido algo. Cualquier cosa me consultan, no hay problema.

Pueden obtener el código, sin todos esos comentarios horribles (jeje), en:
https://sites.google.com/site/mamaquieroserpentester/home/tools (como PortScanner.py)

Eso es todo por ahora.

Saludos y Happy Hacking!

Fake AP + brctl = MITM (te lo "XPLICO"?) - PARTE I

Hola otra vez. Muchas veces les debe haber pasado de leer un artículo o ver un video sobre algún especialista de seguridad en el que, se dirige a un bar, crea un punto de acceso wifi falso y comienza a capturar información de los usuarios que se conectan a él. Podemos ver un ejemplo en uno de los programas de "MUNDO HACKER" en el que el gran Yago Jesús va a una estación de tren y le roba la sesión de facebook a una pobre chica jeje ----> https://www.youtube.com/watch?v=P-XyKvYZNek

En esta entrada, voy a mostrarles una forma sencilla de crear un FAKE ACCESS POINT y como darle conexión a internet a la víctima.  En la próxima entrada les mostraré como capturar e interpretar la información que genera el usuario conectado y les dejaré unos scripts que armé en bash para realizarlo automáticamente.

Para esta primera parte vamos a necesitar (anote doña):

1_Un equipo conectado a internet.
2_Una máquina virtual corriendo Backtrack o Kali.
3_Un adaptador WIFI USB que acepte modo monitor.

El adaptador wifi que usaré será un Signal King ( una de esas baratas y poderosas maravillas chinas). Este adaptador tiene muy buen alcance, lo cual es muy recomendable a la hora de crear un FAKE AP (mientras mas lejos, a mas potenciales clientes podremos llegar). Podemos ver sus características técnicas aquí

Para crear nuestro ROGUE AP (o Fake AP) usaremos la máquina virtual para que obtenga la dirección de red a través de NAT (con lo cual estará conectada a internet por medio de nuestro equipo). Luego pondremos en modo monitor nuestra tarjeta WIFI USB y crearemos el punto de acceso falso. Por último crearemos un puente entre esa conexión y la interfaz conectada a través de NAT. Con esto obtendremos algo así:

Esquema de nuestro FAKE AP

Veamos como hacer esto paso a paso.

Configurando nuestra máquina virtual (usaré VIRTUAL BOX).

Antes de arrancar nuestra máquina virtual ingresaremos a la configuración, y luego, en "Red" habilitamos el Adaptador 1 (o cualquier otro) y elegimos la opción "NAT".

En "USB" recuerden agregar el filtro correspondiente a su adaptador wifi:

Luego, iniciamos Kali.

Iniciando nuestro FAKE AP

Una vez iniciada nuestra máquina virtual, abrimos la consola y ejecutamos lo siguiente para cambiar nuestra tarjeta de red wifi USB a modo monitor:

# airmon-ng start wlan1 (suplantar wlan1 por la interface que utilice su adaptador wifi USB).

Luego ingresamos:

# airbase-ng --essid FAKE_AP mon0 (suplantar FAKE_AP por el nombre que quieran darle a su punto de acceso wifi)

Con esto arrancamos nuestro punto de acceso falso. Presten atención a la nueva interface "at0" que se ha creado. Que es eso?

Una interface tap simula un dispositivo de capa de enlace, con lo cual opera con paquetes de capa 2 y se utiliza para crear puentes.

Esta interface nos permitirá proporcionarle internet a nuestra víctima, pero como?

Ese puente mágico... (como el bifrost para los nórdicos jeje)

Utilizaremos el comando "brctl" (bridge control) que viene incorporado en KALI. Este comando nos permite crear un brigde entre dos interfaces. Podemos ver mas sobre el aquí

Primero ingresamos:

#brctl addbr mitm (suplantar mitm por el nombre que deseemos darle al bridge)

Con esto creamos la interface bridge

Luego ingresamos:

#brctl addif mitm at0 (la interfaz creada al montar nuestro FAKE AP)
#brctl addif mitm eth0 (interfaz donde estamos conectados por NAT)

Con eso unimos las dos interfaces por medio del bridge

Ahora nos queda levantar las interfaces y asignarle una ip a nuestro bridge. Como lo hacemos? Con el comando "dhclient"

#dhclient mitm

Ya tenemos todo listo, ahora, a esperar que se conecte nuestra víctima:

Miren tenemos un invitado!

La parte mas interesante...a jugar con XPLICO!

Una vez que nuestra víctima se conectó a nuestro punto de acceso falso podemos hacer muchas pero muchas cosas (todo lo que se están imaginando y más). En este caso, utilizaré una gran aplicación llamada Xplico. Esta herramienta se encarga de interpretar toda la información que va sniffeando o que hemos sniffeado. Si si, eso es lo bueno, que podemos pasarle tanto un archivo .cap como realizar una captura en vivo y xplico irá interpretando todo por nosotros. Pero eso lo veremos en la próxima entrada.

Espero que les sea de utilidad

Saludos y...

HAPPY HACKING!