Paso a paso actividad 1 – Análisis de vulnerabilidades.

Preparación:

Tener una máquina Kali Linux, puede ser virtual, con acceso a internet. Yo usé VMWare, porque
ya tengo mi máquina de Kali, versión Rolling, ahí, pero debería funcionar igual en VirtualBox. Lo
ideal es que tenga las extensiones del virtualizador instaladas para poder copiar y pegar entre el
host y la VM.

Hay que instalar los paquetes network-manager-openvpn y network-manager-openvpn-gnome

para que el Kali reconozca el perfil de openvpn que se descarga de ihacklabs. Esto se hace con
los comandos:

Apt-get install network-manager-openvpn

Apt-get install network-manager-openvpn-gnome

Una vez hecho esto, en el menú de la página de ihacklabs nos descargamos el perfil de openvpn
y en el Kali lo importamos en la configuración de red, en la parte de VPN.

Con esto nos podemos conectar a la VPN y ya quedamos en la misma red donde está la
máquina objetivo, 10.0.2.39. Hay que arrancar la actividad en la plataforma de ihacklabs para
que suba la máquina objetivo.

Se conectan con la VPN y prueben con ping que la máquina responda. Si responde, todo bien, y
podemos comenzar.

La primera flag nos dice que hay una filtración de datos en un archivo. Lo primero que hay que
hacer es ver qué servicios está corriendo la máquina para determinar donde puede estar esa
filtración. Para esto, exploramos la máquina con nmap. Puede ser un nmap sencillo como

Nmap -v 10.0.2.39

Que solo nos muestra los servicios, o uno mas elaborado como

Nmap -v -sV 10.0.2.39

Que nos muestra también la versión de los servicios que se están ejecutando. En este caso, a la
larga no es relevante ya que no usamos las versiones ni nada. Se me olvidó tomar pantalla del
nmap, asi que ni modo. El caso es que el nmap nos muestra que tiene abiertos el 22 (SSH), el 80
(web server), y el 445 (samba, compartidos tipo Windows).

Aquí empiezan las deducciones. Lo mas lógico es que la filtración sea por el web server ya que
ese es público, por lo que empezamos por ahí. Lo primero es entrar normalmente, con el
navegador, a ver si se ve algo, pero en este caso el web server esta por default:
Esto no nos dice nada, por lo que nos toca explorar todo el sitio a ver que se encuentra. Para
esto se usa dirbuster. Yo lo hice así:

Que es: el sitio web, usar ambos métodos de extracción (HEAD y GET) por si acaso el servidor
no responde por alguno, 200 hilos de conexión para que vaya “mas rápido” (o menos lento),
usando la lista mas completa de palabras, por si acaso, y con las opciones: Buscar directoriosm
archivos, recursivamente (directorios dentro de directorios), archivos sin extensión (yo siempre
busco eso, porque se encuentran cosas interesantes en archivos sin extensión) y, como era un
documento, puse doc. Victor, que es el dueño de esta flag puso pdf. Si colocan pdf ahí ahorran
tiempo, porque lo encuentran todo de una. Eso se va a demorar. Dejenlo ahí hasta que en los
resultados encuentren los resultados juntos de estas dos pantallas:
Dando clic derecho sobre un resultado se puede ver en el navegador. Entren a important.pdf
que es el de esta flag y a passwords que es el de las dos siguientes.

Important.pdf parece no tener nada

Pero recuerden que esta primera flag se llama “metadatos”, así que descarguen ese archivo y
lean sus propiedades (clic derecho en el explorador de archivos/propiedades). Ahí encuentran
la primera flag. Credito total para Victor. A mí se me había pasado por alto.

Seguimos. El archivo password tiene esto:

Como la segunda flag es samba, usaremos las credenciales de samba. Sabemos que esa
maquina tiene un compartido, pero no sabemos cual es. Teniendo el usuario y el password,
examinamos con una herramienta llamada smbmap (se pueden usar otras) explorando
inicialmente con

smbmap -H 10.0.2.39

Encontramos:

Asi que ya sabemos que hay un directorio compartido. Para ver que contiene usamos

smbmap -H 10.0.2.39 -u user -p toor -R (aunque se puede usar otra cosa como smbmount o
entrar al directorio)

Y encontramos:
Un archivo flag.txt. Lo descargamos con

smbmap -H 10.0.2.39 -u user -p toor –download ‘sambashare\flag.txt’ (o lo copiamos de

cualquier otra manera).

Lo abrimos y obtenemos la segunda flag.

La tercera es la más complicada. Sabemos que hay que explotar una aplicación, asi que toca
entrar a la maquina. Ya tenemos las credenciales SSH, así que solo es usar

Ssh level1@10.0.2.39

Para entrar. Una vez adentro, nos dan unas pistas:

Esto nos indica que tenemos que leer un archivo .pass, por lo que lo primero que hacemos es
un ls -la para ver que archivos hay:
Ahí esta el .pass, pero no tenemos permisos para leerlo. Toca ver que mas hay. Hay un
ejecutable (level1) que si lo corremos nos devuelve de salida lo mismo que le demos de
entrada:

Eso no ayuda. Veamos que dice el código fuente (level1.c) con cat:

Ajá. Un código fuente que nos dice que hay una función que no esta referenciada, o des que no
se ejecuta, pero que hace lo que necesitamos. Leer el flag como root. Tenemos que hacer que
se ejecute. Para esto se usa una técnica de buffer overflow. Básicamente la idea es escribir
tantos caracteres en la entrada que se llene el almacenamiento y el sistema tenga que escribir
los sobrantes en el registro donde se guarda la dirección de memoria que se va a ejecutar
después. Así podríamos escribir la dirección de memoria donde está esa función y el sistema
operativo la ejecutará.

Lo primero entonces es saber cual es esa dirección. La forma más fácil es entrar al debugger
gdb con

Gdb level1

Y ejecutar el comando

Info functions

Eso nos da lo que necesitamos:

La dirección de memoria de la función es 0x080485bb. Toca entonces llenar el buffer de
entrada con caracteres hasta que saque el error “illegal instruction” o “segmentation fault”. El
profesor explico una forma de medio automatizar esto con perl en la clase, pero este programa
no recibe argumentos. Una forma es hacerlo a mano. Correr el programa y meter caracteres
primero 20, después 21, después 22… hasta que salga illegal instruction. Eso significa que ya
sobreescribimos el puntero y trato de ejecutar una dirección invalida.

Para comprobar se pone en la siguiente prueba un carácter mas. Debe salir “segmentation
fault”. Esto es, si ingresamos por ejemplo 20 caracteres y sale bien, probamos 21. Si ahí sale
“illegal instruction” probamos 22 y debe salir “segmentation fault”. Si es así ya estamos seguros
que a partir del carácter 21 podemos escribir nuestra dirección de memoria (en hexadecimal e
invertida, ya que el procesador usa el sistema Little endian y por eso lee “al revés” las
direcciones).

En este caso el valor es 32, pero tuve problemas haciendo que me recibiera la dirección es
hexadecimal. El formato es \xnumero en pares de a dos, así que en nuestro caso sería:

Direccion hexadecimal: 0x080485bb

Direccion a introducir (invertida y con formato): \xbb\x85\x04\x08

El caso es que directamente no me lo estaba tomando así que me tocó usar la función printf
que manda la secuencia de caracteres correcta y dársela como entrada al archivo. Esto también
se puede usar para ir probando hasta que salgan los errores, que fue lo que yo hice y después
mandé la cadena:
Y ahí esta la tercera flag (que yo pensé que era la primera y que encontré al principio).