Bocata de Calamares - TheHackerLabs
Esta fue una máquina fácil. Después de analizar los escaneos, vamos directo a la página web activa en el puerto 80, siendo una página de fake news. Aplicando Fuzzing, descubrimos un login al que es posible aplicarle Inyecciones SQL. Gracias a esto, ganamos acceso a este login y encontramos una lista por hacer, en la que menciona un lector de archivos internos, al que codificaron su nombre en base64. Encontramos y analizamos el lector de archivos internos, este nos permite leer archivos como el /etc/passwd. Además, encontramos una pista en el código fuente, mencionando que se le puede aplicar fuerza bruta a un usuario del servicio SSH. Le aplicamos fuerza bruta con hydra a uno de los usuarios que vimos en el /etc/passwd, y ganamos acceso principal a la máquina víctima vía SSH. Revisamos los privilegios de este usuario, descubriendo que podemos usar el binario find como Root. Utilizando la guía de GTFOBins, encontramos una forma de escalar privilegios, convirtiéndonos en Root.
Esta fue una máquina un poco complicada. Después de analizar los escaneos, descubrimos que la página web activa del puerto 80, está utilizando Virtual Hosting, por lo que agregamos la IP y el dominio al /etc/hosts para que nos cargue bien la página. Ya en la página, vemos que fue hecha con WordPress y que solo tiene un usuario registrado, así que utilizamos WPScan para enumerarla y encontrar algún plugin que sea utilizado y sea vulnerable. Resulta que la página utiliza el plugin NotificarionX versión 2.8.2, que es vulnerable a Unauthenticated Blind SQL Injection. Investigando un poco, encontramos un Exploit en la página web de Vicarius que usamos para obtener el hash del administrador del sitio, mismo hash que logramos crackear con JohnTheRipper y usando al usuario que ya habíamos encontrado antes, logramos ganar acceso al login de WordPress. Dentro del login, modificamos el archivo PHP de un tema para que nos sirva como WebShell y nos podamos mandar una Reverse Shell, ganando acceso principal a la máquina...
Después de analizar los escaneos, pasamos a analizar las dos páginas web activas. Descubrimos el uso de Webmin en la página web activa del puerto 10000. También descubrimos una pista en el código fuente de la página web activa en el puerto 8088 y aplicando Fuzzing, descubrimos un login al que le aplicamos fuerza bruta para ganar acceso. Al entrar, vemos que es una WebShell, lo que nos permite ejecutar una Reverse Shell desde un servidor web remoto de Python de nuestra máquina, con tal de ganar acceso a la máquina víctima. Ya en la máquina, descubrimos que nuestro usuario puede ejecutar la Bash con privilegios de Root, lo que nos permite escalar privilegios fácilmente para ser Root. Además, encontramos un archivo con credenciales de acceso al Webmin. Al entrar, vemos que es posible utilizar la Shell de Comandos y la Terminal para mandarnos una Reverse Shell, pero al recibirla, resulta que ganamos acceso como Root, pues es este quien ejecuta el Webmin.
Esta fue una máquina un poco complicada. Después de analizar los escaneos de servicios y de no encontrar nada en la página web activa en el puerto 80, aplicamos Fuzzing para encontrar algún directorio oculto. Encontramos uno y resulta ser una página que permite subida de archivos, solo si tienes las credenciales de acceso correctas. Aplicamos el Cluster Bomb Attack con BurpSuite para descubrir las credenciales válidas y luego, aplicamos un Sniper Attack con BurpSuite para aplicar un bypass a la blacklist de extensiones no permitidas, siendo que logramos subir una WebShell de PHP con la que obtenemos una Reverse Shell y ganamos acceso principal a la máquina víctima. Dentro, enumeramos los archivos de la máquina y descubrimos un archivo como backup que resulta ser una llave privada id_rsa, que logramos crackear con JohnTheRipper y luego usamos esa llave privada para ganar acceso a la máquina víctima vía SSH. Dentro del SSH, revisamos los privilegios de nuestro usuario, descubriendo que puede usar el binario ...
Esta fue una máquina sencilla, pero que necesita bastante trabajo para terminarla. Después de analizar los escaneos y no encontrar nada en la página web activa en el puerto 80, aplicamos Fuzzing y descubrimos una página web que fue creada con WordPress. Enumeramos WordPress y al no encontrar alguna vulnerabilidad, aplicamos fuerza bruta al usuario admin, de quien obtenemos su contraseña y ganamos acceso al login de WordPress. Dentro, modificamos un tema para que uno de sus archivos ejecute comandos, siendo este método por el que aplicamos y obtenemos una Reverse Shell de la máquina víctima. Al no encontrar algo en la máquina víctima, leemos el archivo wp-config.php, que contiene credenciales de acceso al servicio MySQL, y enumeramos las bases de datos de MySQL, descubriendo así un hash MD5 que logramos crackear y resultando en la contraseña del único usuario de la máquina, con lo que ganamos acceso vía SSH. Al comprobar si estaba activo el servicio MySQL, descubrimos un puerto activo que resulta ser una pá...
Esta fue una máquina algo complicada. Después de analizar los escaneos, analizamos la página web activa en el puerto 80, pero al no poder aplicarle Fuzzing, descubrimos que es probable que utilice un WAF, por lo que utilizamos una cabecera User-Agent personalizada, lo que nos permite descubrir una página de envío de paquetes. Dicha página tiene un formulario que resulta ser vulnerable al ataque XML External Entity (XXE). Gracias al XXE, descubrimos que está activo el servicio FTP y que la página está desplegada en un contenedor de Docker. Aplicamos XXE + PHP Wrappers para leer el archivo que procesa el XML, encontrando ahí un archivo que es una base de datos de KeePass. Dicho archivo, lo obtenemos del servicio FTP activo, lo crackeamos y obtenemos las credenciales de un usuario con el que ganamos acceso al contenedor de Docker. Dentro del contenedor, descubrimos archivos de otro usuario, entre ellos, una llave id_rsa que no tiene contraseña, lo que nos permite ganar acceso a la máquina víctima. Dentro de l...
Esta fue una máquina sencilla. Después de analizar el escaneo de servicios, vemos información interesante en el servicio FTP activo en el puerto 21 de la máquina víctima, por lo que entramos a este como el usuario anonymous. Al entrar, vemos un mensaje de bienvenida a un usuario y encontramos un archivo de texto con algunos posibles usuarios. Utilizamos al usuario a quien se le da la bienvenida para aplicarle fuerza bruta por FTP y SSH con hydra, logrando obtener su contraseña para ambos servicios, siendo la misma. Dentro de la máquina, revisamos los privilegios que tenemos, descubriendo que podemos usar una copia del binario timeout como Root. Utilizamos la guía de GTFOBins para encontrar y usar una forma de escalar privilegios, convirtiéndonos así en Root.
Esta fue una máquina algo complicada, pues necesita bastante trabajo para terminarla. Después de analizar los escaneos y un login del puerto 80 que no lleva a nada, nos vamos a la página web del puerto 8080, que resulta ser el login del CI/CD Jenkins. Aplicamos fuerza bruta a este login y ganamos acceso al Dashboard de Jenkins. Abusamos de la Consola de Scripts para poder mandarnos una Reverse Shell de Groovy a nuestra máquina, obteniendo el acceso principal. Enumerando la máquina, descubrimos que hay 5 usuarios y que nuestro usuario actual, tiene privilegios para usar el binario find. Ocupamos la guía de GTFOBins para abusar de este binario y nos convertimos en el usuario 1. De aquí en adelante, ocuparemos mucho la guía de GTFOBins. El usuario 1, tiene privilegios para usar el binario aws, al que le aplicamos Shell Escape para convertirnos en el usuario 2. El usuario 2, tiene privilegios para usar el binario crash, al que también le aplicamos Shell Escape y nos convertimos en el usuario 3. El usuario 3, t...
Esta fue una máquina sencilla, pero que necesita bastante análisis. Después de analizar el escaneo, analizamos la página web activa en el puerto 80, donde encontramos un comentario en su código fuente. Al no encontrar algo más, aplicamos Fuzzing, descubriendo así un directorio oculto que contiene pistas, hashes y un archivo cifrado. Descargamos el directorio y analizamos los hashes, logrando crackear casi todos con la página Crackstation. El último hash lo logramos crackear creando un wordlist de la contraseña encontrada en el código fuente de la página web con crunch. Luego, utilizamos esa contraseña para ganar acceso a la máquina vía SSH como el usuario dueño de los hashes. A su vez, identificamos una clave para descifrar el archivo encriptado, esto dentro de un archivo de texto, logrando descifrarlo con openssl y obteniendo la contraseña del usuario dueño del archivo encriptado, pero dicha contraseña no funciona. Como el primer usuario encontrado, descubrimos que tiene privilegios para usar el binario e...
Esta fue una máquina algo complicada. Después de analizar la página web del puerto 5000, que utiliza Werkzeug y Flask, descubrimos que es vulnerable a XSS y a Server Side Template Injection (SSTI), siendo así que logramos ganar acceso a la máquina víctima. Enumerando la máquina, descubrimos que hay un contenedor de Docker que tiene una página web activa en el puerto 80, así que aplicamos Reverse Port Forwarding para poder ver y analizar esa página. Luego de aplicarle Fuzzing, descubrimos una página que nos permite subir archivos. Aplicamos un Sniper Attack con la herramienta Intruder de BurpSuite para descubrir qué extensiones de archivos puede aceptar, logrando descubrir una extensión que nos permite subir una Reverse Shell con la que ganamos acceso al contenedor de Docker. Dentro del contenedor, descubrimos un mensaje que nos da una pista sobre dónde encontrar la contraseña del usuario Root. Además, descubrimos que nuestro usuario tiene privilegios para usar los comandos cut y grep como Root, por lo que ...
Esta fue una máquina sencilla. Después de descubrir que se aplicaba Virtual Hosting y de registrar el dominio en el /etc/hosts, logramos entrar a la página web activa, pero al no encontrar nada, revisamos el código fuente, en donde encontramos el nombre de un usuario. Aplicamos fuerza bruta al usuario que encontramos, logrando ganar acceso a la máquina víctima vía SSH. Dentro, descubrimos que este usuario está dentro del grupo de Docker, lo que nos permite crear un contenedor que almacena una montura de la raíz del sistema de la máquina. Gracias a esto, también podemos generar cambios que se verán reflejados fuera del contenedor, con lo que logramos escalar privilegios al darle permisos SUID a la Bash.
Esta fue una máquina algo complicada. Después de analizar los escaneos, pasamos a analizar las páginas web activas, pero nos enfocamos en la que muestra un login en el puerto 3333. Logrando pasar el login utilizando credenciales por defecto, analizamos el comportamiento de la página admin, que nos permite cargarle una URL y descargar algo. Descubrimos que es posible que sea vulnerable a Server Side Prototype Pollution, pues está ocupando Node JS Express, siendo un framework vulnerable a esto. Probamos y aplicamos un payload que nos da privilegios de administrador, lo que nos permite utilizar de manera funcional la página admin. Además, probamos que también es vulnerable a ejecución de comandos, pues está utilizando la función exec(), siendo una función vulnerable. Aprovechamos esto para obtener una Reverse Shell y al fin conectarnos a la máquina víctima. Dentro, utilizamos la herramienta pspy64 para identificar tareas CRON en segundo plano. Identificamos que se ejecuta un script vacío cada minuto y que pod...
Esta fue una máquina sencilla, pero que necesita bastante trabajo el resolverla. Después de descubrir que se aplica Virtual Hosting, registramos un posible dominio, con el que podemos ver la página web activa. Descubrimos que se está utilizando el CMS Pluck 4.7.18, el cual es vulnerable a Remote Code Execution (Authenticated). Aplicando Fuzzing, descubrimos un archivo que contiene la contraseña del admin del CMS Pluck, pero esta codificada en base64 varias veces. Una vez decodificada, ganamos acceso al login de Pluck y explotamos la vulnerabilidad del CMS Pluck 4.7.18 de forma manual, logrando obtener una Reverse Shell y ganando acceso principal a la máquina víctima. Dentro de la máquina, encontramos un archivo de texto que contiene un par de claves, una codificada en cifrado Playfair y otra en base64. Decodificamos ambas claves y descubrimos la contraseña de un usuario de la máquina, lo que nos permite autenticarnos vía SSH. Ya como este usuario, encontramos un binario dentro de su directorio que contiene...
Esta fue una máquina sencilla. Después de aplicar Fuzzing, encontramos un directorio oculto. Dicho directorio, solamente tiene un archivo que muestra un mensaje que nos da una pista de lo que tenemos que hacer. Aplicamos fuerza bruta al servicio SSH, encontrando un usuario y contraseña válidos con los que podemos ganar acceso a la máquina víctima. Dentro de la máquina, revisamos los privilegios de nuestro usuario, descubriendo que podemos utilizar el binario base64 como Root. Utilizamos la guía de GTFOBins para encontrar una forma de escalar privilegios con este binario. Encontramos que el binario base64 nos permite ver archivos que solamente el Root puede, siendo de esta forma que logramos copiar la llave privada id_rsa. Logramos crackear la llave privada y nos autenticamos como Root en la máquina víctima.
Esta es una máquina fácil, pero que necesitas prestar mucha atención a todo lo que te encuentres. El reto de la máquina es obtener 9 flags que encontrarás conforme vulneres los servicios activos. Comenzamos primero enumerando el servicio FTP, donde encontramos una flag y un archivo ZIP. Luego, analizamos la página web en donde encontramos varias vulnerabilidades, siendo que aquí encontramos un usuario y contraseña que nos permiten ganar acceso a la máquina vía SSH. Dentro de la máquina, encontramos una pista que resulta ser una contraseña para poder descomprimir el archivo ZIP que habíamos encontrado, siendo otra pista para la contraseña del servicio MySQL. Creamos un wordlist con esta pista y aplicamos fuerza bruta al servicio MySQL, logrando encontrar la contraseña y ganar acceso al MySQL. Enumeramos las bases de datos y encontramos una que contiene la contraseña de otro usuario. Nos autenticamos como este usuario y descubrimos que tiene privilegios de Root para usar la Bash, con lo que logramos escalar ...
Esta es una máquina sencilla, pero que necesita bastante trabajo para resolverla. Comenzamos analizando la página web, pero al no encontrar nada que nos ayude, aplicamos Fuzzing para encontrar directorios ocultos. De esta forma, encontramos un directorio que contiene un archivo de texto con una pista, pero que no podremos usar de momento. Analizando de nuevo la página web principal, probamos un título mencionado en el contenido, resultando en una página oculta. Dicha página, permite subir e incluir archivos, siendo la inclusión de archivos vulnerable a Local File Inclusion (LFI). La subida de archivos, permite subir archivos PHP, lo que nos permite subir una WebShell de PHP, pero al no saber donde ni como se suben los archivos, utilizamos el LFI más PHP Wrappers para obtener el script completo de esta página para analizarlo, siendo así que descubrimos donde se guardan y que el nombre se codifica en ROT13. Sabiendo esto, codificamos el nombre de nuestra WebShell a ROT13 y logramos usarlo en la ruta donde se...
Esta fue una máquina un poco complicada. Después de analizar los escaneos, analizamos la página web activa en el puerto 8089, en donde realizamos varias pruebas en un input para determinar si es vulnerable a XSS, resultando positivo. Al ver que ocupa Werkzeug, probamos y descubrimos que la página es vulnerable a Server Side Template Injection (SSTI) en el mismo input vulnerable. Con esta vulnerabilidad, nos mandamos una Reverse Shell y ganamos acceso a la máquina víctima. Revisando los privilegios de nuestro usuario, encontramos que podemos usar el binario pydoc3 como Root. Probando el binario, resulta ser similar al comando man, por lo que nos aprovechamos de esto para aplicar Shell Escape y así nos convertimos en Root.
Esta fue una máquina sencilla, pero que me complique un poco. Al analizar los escaneos de puertos y servicios, y solamente ver 2 puertos activos, nos dirigimos al puerto 10000 que está ejecutando Webmin 1.920. Investigando un poco, encontramos que esta versión es vulnerable a ejecución remota de código (RCE). Probamos 2 Exploits, uno de Metasploit Framework para ganar acceso a la máquina y otro que comprueba si la versión de Webmin usada, es vulnerable a RCE. Además, se hace un PoC de la vulnerabilidad y se genera un Exploit que automatiza la obtención de una Reverse Shell. Ya dentro de la máquina, usamos linpeas.sh para encontrar algo que nos ayude a escalar privilegios, siendo así que descubrimos que el binario gdb tiene capabilities peligrosas, de las que nos aprovechamos para convertirnos en Root, gracias a la guía de GTFOBins.
Esta es una máquina bastante difícil. Después de analizar los escaneos, iniciamos con la página web activa en el puerto 80, descubriendo que podemos descargar archivos PDF. Una vez descargador, analizamos sus metadatos con exiftool, notando que cada PDF tiene un nombre de usuario, así que aplicamos Fuzzing para comprobar si existen más PDFs, siendo así que descubrimos 188 PDFs. Creamos un script con Python para descargar todos estos PDFs y los analizamos todos con exiftool para obtener todos los nombres de usuarios, con tal de crear un wordlist de usuarios. Enumeramos Kerberos con kerbrute usando este wordlist, descubriendo un usuario válido. Después, analizamos el contenido de cada PDF con pdfgrep y descubrimos la contraseña de este usuario en un PDF. Utilizamos este usuario para enumerar el servicio RCP y LDAP, siendo así que descubrimos un usuario que agregó su contraseña en la descripción de su usuario. Utilizamos este segundo usuario para enumerar el servicio SMB, descubriendo un script de PowerShell ...
Esta fue una máquina un poco complicada. Después de analizar los escaneos, nos damos cuenta de que no podremos entrar al servicio FTP activo y la página web activa en el puerto 80, solamente muestra la página por defecto de Apache2. Entonces, empezamos aplicando Fuzzing para ver qué podíamos encontrar, siendo que así encontramos un directorio que, al entrar, nos muestra un mensaje, mencionando a un usuario. Tomamos a ese usuario mencionado, para aplicar Fuerza Bruta al servicio SSH y FTP, logrando obtener su contraseña y ganando acceso a ambos servicios. Dentro, no encontramos alguna forma de escalar privilegios, pero sí encontramos otro usuario registrado al que igual le aplicamos Fuerza Bruta, siendo que obtuvimos su contraseña para el servicio SSH y FTP. Logueándonos como este nuevo usuario en SSH, descubrimos que tiene el privilegio de usar el binario man como Root. Utilizamos la guía de GTFOBIns para escalar privilegios usando este binario, con lo que aplicamos un Shell Escape y nos convertimos en Roo...
Esta fue una máquina sencilla, pero que necesitas comprender bien el Exploit. Después de analizar los escaneos y de caer en un engaño de un archivo de texto con una cadena en ROT13, analizamos la página web activa que está ocupando el software ElkArte Forum, siendo que descubrimos la versión que se está ocupando y que existe un Exploit para esta. Logramos entrar al login de ElkArte Forum como el usuario admin con credenciales simples por defecto y aplicamos el Exploit, logrando subir una WebShell de PHP, que nos permite obtener una Reverse Shell, con lo que ganamos acceso principal a la máquina víctima. Dentro de la máquina, encontramos un archivo ZIP que logramos crackear y obtener su contenido, siendo la contraseña de un usuario registrado en la máquina. Revisando los privilegios de este usuario, encontramos que podemos usar el binario scp como Root. Buscando en la guía de GTFOBins, encontramos la forma de poder escalar privilegios con este binario y así logramos convertirnos en Root.
Esta es una máquina algo compleja. Después de analizar los escaneos, descubrimos que hay dos páginas webs activas, una en el puerto 80 y otra en el puerto 5000. También vemos activo el puerto 21 del servicio FTP, siendo que podemos entrar como el usuario anonymous, pero solo encontramos un archivo de texto que no da ninguna pista. Analizando y aplicando Fuzzing a la página web del puerto 80, no encontramos algo útil. Analizando el código fuente de la página web del puerto 5000, encontramos un comentario que es un directorio web que, al visitarlo, vemos que nos permite enviar data en un input. Haciendo pruebas en el input, resulta que es vulnerable al ataque Server Side Template Injection. Esto último lo sabemos porque la página utiliza Werkzeug. Sabiendo y probando esto, aplicamos una Reverse Shell con la que ganamos acceso a la máquina. Dentro de la máquina y después de enumerarla, descubrimos que estamos dentro del grupo Disk, lo que nos permite entrar en una partición del disco del sistema. Ya en la par...
Esta fue una máquina sencilla. Después de analizar los escaneos, pasamos a analizar la página web que encontramos en el puerto 80, siendo que en su código fuente, encontramos un comentario que resulta ser un código Brainfuck. Decodificando este código, descubrimos que es una contraseña, la cual separamos por partes y aplicamos Password Spraying en los servicios activos, para identificar si el usuario se encuentra en la contraseña, siendo que así lo encontramos y ganamos acceso al servicio FTP. Dentro del FTP, encontramos una base de datos de KeePass, que descargamos y crackeamos, resultando en el usuario y contraseña para entrar al servicio SSH. Dentro del SSH, vemos que nuestro usuario puede usar el binario chown como Root, lo que nos permite cambiarle los permisos al archivo /etc/passwd, con tal de que nuestro usuario pueda modificarlo y así escalar privilegios de varias maneras.
Esta fue una máquina lo suficientemente difícil. Después de analizar el escaneo de servicios, empezamos revisando la página web, que al no encontrar nada, aplicamos Fuzzing a directorios web, en donde encontraremos algunos que contienen imágenes, letras de canciones (entre ellas un wordlist) y un mensaje de un usuario que resulta ser una pista. Enumeramos los usuarios del servicio Kerberos con kerbrute y aplicamos fuerza bruta al servicio SMB, utilizando el wordlist encontrado, siendo así que encontramos la contraseña de un usuario. Esto nos permite loguearnos al servicio WinRM con evil-winrm. Además, aplicamos el AS-REP Roasting attack, logrando crackear el hash krb5asrep que resultó ser del mismo usuario al que obtuvimos su contraseña con la fuerza bruta al SMB. También aplicamos estegoanalisis a las imágenes encontradas, resultando en encontrar y obtener un archivo que contiene la contraseña de otro usuario. Para terminar, analizamos el AD con SharpHound v1.1.1 y BloodHound Community Edition, descubrien...
Esta fue una máquina un poco complicada. Después de analizar los escaneos, descubrimos que la página web activa en el puerto 80, está utilizando el CMS Pluck 4.7.13 y lo comprobamos con la herramienta whatweb, el login al que podemos entrar desde la página principal. Aplicando Fuzzing, descubrimos que hay un directorio que contiene un archivo ZIP, el cual descargamos y crackeamos para poder descomprimirlo. Adentro del archivo ZIP, encontramos la contraseña del usuario admin del CMS Pluck. Buscando un Exploit para la versión de Pluck, encontramos uno que permite subir una WebShell y lo aplicamos. Con la WebShell, obtenemos una Reverse Shell para tener una sesión de la máquina víctima. Enumerando la máquina, encontramos otro archivo ZIP, que crackeamos y descomprimimos, siendo que contiene un archivo de texto que muestra un hash desconocido. Utilizando CyberChef, identificamos y decodificamos el hash, siendo un hash en base58. Este hash es la contraseña de un usuario de la máquina víctima, lo que nos permite...
Esta fue una máquina sencilla, pero que necesita su trabajo. Después de analizar los escaneos, entramos a la página web activa en el puerto 80, que vemos que utiliza Virtual Hosting. Aplicando Hovering y registrando el dominio en el /etc/hosts, identificamos que la página es el CMS Bludit. Aplicando Fuzzing, descubrimos el login del CMS Bludit y lo analizamos para ver como se tramita la data del login, para aplicarle fuerza bruta. Al notar que la fuerza bruta será complicada de aplicar, buscamos algún Exploit que se le pueda aplicar, encontrando así un Exploit que aplica fuerza bruta. Utilizamos este Exploit para ganar acceso al login del CMS Bludit. Entre los Exploits encontrados, también encontramos uno que aplica Directory Traversal, que utilizamos para cargar una WebShell y con esto nos mandamos una Reverse Shell para ganar acceso a la máquina víctima. Enumerando la máquina, encontramos un archivo del CMS Bludit que contiene los hashes de las contraseñas de los usuarios, siendo que uno de estos hashes ...
Una máquina que es lo suficiente complicada. Después de analizar los escaneo e identificar que estamos contra una máquina que es Active Directory, vemos que es posible ver los recursos compartidos con el usuario guest. Ahí, encontramos un archivo que contiene una conversación entre varios personajes de Doraemon. Copiamos los nombres de estos personajes y otros más que aparecen en el mensaje, para aplicar Password Spraying con tal de identificar si algún usuario utilizo su propio usuario como contraseña. Encontramos a un usuario que usa como contraseña el nombre de un grupo, descrito en el mensaje y dicho usuario pertenece al servicio WinRM, lo que nos permite loguearnos con la herramienta Evil-WinRM. Una vez dentro, utilizamos winPEASx64.exe para enumerar la máquina, siendo así que encontramos un archivo oculto que contiene la contraseña de otro usuario. Para descubrir a qué usuario pertenece esa contraseña, volvemos a aplicar Password Spraying y lo encontramos, siendo que también pertenece al servicio Win...
Esta fue una máquina sencilla, pero que te puede desorientar un poco. Analizando los escaneos, podemos ver que tiene 4 puertos abiertos, pero da curiosidad ver el puerto 21 y el puerto 8080 activos. En el escaneo de servicios, descubrimos que el puerto 8080 está utilizando el servicio Jenkins y que podemos entrar al servicio FTP como el usuario anonymous. Dentro del FTP, encontramos un archivo de texto que contiene una pista de un usuario, que nos pide aplicar fuerza bruta al login de Jenkins. Aplicando fuerza bruta, encontramos la contraseña de este usuario. Dentro, aplicamos una Reverse Shell en la consola de Groovy para ganar acceso a la máquina víctima. Ya en la máquina, podemos autenticarnos como el usuario que nos dejó la pista, ya que reutilizó la misma contraseña. Como este usuario, descubrimos que no tiene privilegios, por lo que buscamos una forma de escalar privilegios, siendo un binario SUID el que nos ayudará junto a la guía GTFOBins.
Esta fue una máquina un poco complicada. Analizando los escaneos de servicios, encontramos que el puerto 80 está utilizando WordPress y que está expuesto el puerto 3306 del servicio MySQL. Después de analizar la página web, utilizamos la herramienta wpscan y el módulo wordpress_scanner de Metasploit Framework para buscar plugins vulnerables, siendo así que encontramos el plugin wpDiscuz que explotamos para ganar acceso a la máquina víctima. Una vez dentro, buscamos el archivo config.php para ver las credenciales de acceso al servicio MySQL. Logrando entrar al MySQL, enumeramos la base de datos de WordPress, encontrando una tabla que contiene las credenciales de acceso de un usuario para el servicio SSH. Dentro del SSH, vemos que podemos usar el binario most con privilegios de Root, siendo de esta manera que logramos copiar su llave privada, la crackeamos y nos logueamos como Root. Además, probamos que es posible aplicarle Shell Escape a este binario, siendo otra forma de escalar privilegios.
Esta fue una máquina sencilla. Analizando el escaneo de servicios, nos damos cuenta de que podemos utilizar el usuario guest para entrar en el servicio SMB y que podemos visitar una página web activa en el puerto 80. Al visitar la página y no encontrar nada, pasamos a enumerar el servicio SMB, encontrando un script bat que se ejecuta con privilegios de administrador cada minuto. Descargamos y modificamos este script para que ejecute una Reverse Shell, con tal de poder conectarnos a la máquina víctima, siendo que nos conecta como el Administrador.
Esta fue una máquina algo complicada. Analizando los escaneos, descubrimos que hay 4 puertos abiertos, de los cuales 3 de estos están mostrando páginas web, el puerto 80 una página normal, el puerto 3333 un login y el puerto 8080 la página por defecto de Apache2, así que analizamos las 3 páginas, con tal de encontrar un vector de ataque. Aplicando Fuzzing en el puerto 8080, descubrimos el directorio cgi-bin y un archivo, por lo que probamos el ataque ShellShock que nos permitió ejecutar comandos. De esta forma obtuvimos una Reverse Shell y nos conectamos a la máquina, pero resulta que entramos dentro de un contenedor, por lo que aún falta entrar en la verdadera máquina. Enumerando el contenedor, encontramos unas credenciales ocultas que nos permiten entrar al login del puerto 3333. Analizando el funcionamiento de esta página, probamos la vulnerabilidad Server Side Prototype Pollution, que nos permitió escalar privilegios y convertirnos en admin de la página. Una vez como admin, probamos inyección de comand...
Una máquina que es lo suficientemente complicada y que necesitas paciencia. Después de analizar los escaneos, entramos a la página web activa. Al no encontrar nada útil, aplicamos Fuzzing, siendo así que encontramos un archivo oculto de PHP. Al revisar este archivo, resulta ser una copia de la página principal. Siendo un archivo PHP, aplicamos Fuzzing para descubrir si ocupa un parámetro con la herramienta wfuzz y usando payloads que aplican LFI. Encontrando el parámetro correcto y viendo que funciona el LFI, tratamos de obtener la llave privada de un usuario, siendo que la encontramos en el directorio /opt. Crackeamos la llave y logramos ganar acceso a la máquina víctima. Dentro, vemos que podemos ocupar un binario llamado smokeping como otro usuario. A este binario, le aplicamos Shell Escape para escapar del manual del binario y convertirnos en el otro usuario. Al no poder ver qué privilegios tiene este usuario, encontramos que pertenece al grupo LXD. Logramos escalar privilegios aprovechandonos de este ...
Esta fue una máquina sencilla. Después de analizar los escaneos, nos damos cuenta que está activo el servicio Rejetto HFS en el puerto 80, así que lo visitamos y descubrimos la versión que está utilizando. Esto nos ayuda a buscar un Exploit acorde a la versión encontrada, lo que nos permite Explotar este servicio y ganar acceso a la máquina. Una vez dentro, notamos que tenemos el privilegio SeImpersonatePrivilege, lo que nos permite el uso del Exploit Juicy Potato para poder escalar privilegios.
Esta fue una máquina sencilla. Después de realizar los escaneos, vamos a analizar la página web activa. Analizando el código fuente, descubrimos un mensaje que nos da una pista de un posible usuario que podemos usar en el servicio SSH. Aplicamos fuerza bruta a este usuario y descubrimos su contraseña. Dentro del SSH, revisamos los privilegios de nuestro usuario, siendo que podemos usar el binario gcc como otro usuario. Utilizando la guía de GTFOBins, utilizaremos el binario gcc para escalar privilegios y convertirnos en ese nuevo usuario. Como el nuevo usuario, revisamos sus privilegios y descubrimos que puede usar el binario man como el usuario Root. Aprovechamos esto para escalar privilegios volviendo a utilizar la guía de GTFOBins y nos convertimos en Root.
Una máquina no tan complicada, pero que necesita bastante trabajo resolverla. Después de ver el escaneo y no ver más que solo la página por defecto de Apache2, aplicamos Fuzzing, que descubre un archivo con un mensaje dirigido a un usuario, indicando que existe un contenedor de Docker que tiene activo Grafana 8.3.0 y un archivo de texto con una contraseña para una base de datos. Aplicamos fuerza bruta al usuario encontrado y logramos obtener su contraseña, con lo que entramos al servicio SSH. Dentro, encontramos un nuevo usuario y un archivo que es una base de datos de KeePass. Aplicando Ping Sweep con un script, encontramos la IP que está utilizando el contenedor de Docker. Aplicamos Port Forwarding de varías maneras, para poder ver la página de Grafana. Investigando la versión de Grafana usada, encontramos que tiene la vulnerabilidad Path Traversal, que aprovechamos para ver el archivo que contiene la contraseña de la base de datos de KeePass. Dentro de esa base de datos, encontramos la contraseña del ot...
Una máquina que te puede sorprender si te confías. Después de analizar los escaneos, descubrimos una página web activa, descubrimos que no es necesario loguearnos en el servicio SMB para listar los recursos compartidos y que el servicio MSSQL se encuentra activo. Aplicando Fuzzing a la página web, descubrimos las credenciales de acceso, pero no podemos aprovecharnos de las funciones de la página, por lo que la descartamos. Enumerando el servicio SMB, descubrimos un archivo que contiene las credenciales de acceso del servicio MSSQL. Utilizando netexec, comprobamos que podemos loguearnos en el servicio MSSQL. Ya dentro del MSSQL, habilitamos el xp_cmdshell para ejecutar comandos, del que nos aprovechamos para aplicar una Reverse Shell y así obtener una sesión de la máquina víctima, siendo que nos conecta como el usuario Administrador.
Esta fue una máquina bastante sencilla. Analizando el código fuente de la página web activa de la máquina víctima, encontramos un código oculto que fue hecho en lenguaje Brainfuck. Decodificándolo, descubrimos que parece ser una contraseña. Al no encontrar nada más en la página web, utilizamos la contraseña encontrada para separarla en palabras y usarla con hydra, con tal de probar si se utilizó un usuario para crear la contraseña, siendo que así encontramos un usuario válido. Utilizando las credenciales encontradas, entramos al servicio SSH. Dentro del SSH, vemos los privilegios que tenemos, siendo que podemos utilizar el binario node como Root, que, investigando en la página GTFOBins, encontramos la forma de escalar privilegios.
Esta fue una máquina sencilla. Después de analizar el escaneo y de revisar que la página web solamente muestra la página por defecto de Apache2, decidimos aplicar Fuzzing, con lo que encontramos un directorio de WordPress. Revisando este directorio, solo logramos identificar un dominio que guardamos en el archivo /etc/hosts. Aplicandole Fuzzing a este directorio, ubicamos el login de WordPress, pero nada más. Utilizando wpscan y el módulo wordpress_scanner de Metasploit, identificamos un usuario, al que le aplicamos Fuerza Bruta con hydra y con wpscan, resultando en un exito con ambas herramientas. Entrando al login de WordPress, vemos que podemos subir archivos gracias a un plugin. Nos aprovechamos de esto para subir una Reverse Shell y ganamos acceso a la máquina. Dentro de la máquina, revisamos con pspy las tareas CRON activas, descubriendo el uso de un script inexistente que aprovecharemos para suplantarlo y cambiarle los permisos de la Bash para escalar privilegios.
Esta fue una máquina algo complicada. Después de analizar los escaneos, descubrimos que estamos ante un Active Directory (AD) y asumimos que no podemos hacer nada más que comenzar a enumerar usuarios al servicio Kerberos, esto para encontrar usuarios válidos que puedan ser utilizados para enumerar el servicio SMB. Encontrando un usuario válido, podemos enumerar los recursos compartidos del SMB en donde encontramos una contraseña de otro usuario. Aplicando Password Spraying, descubrimos a quién le pertenece esta contraseña. Usamos esas nuevas credenciales para volver a enumerar los recursos compartidos del SMB, encontrando otro archivo que contiene una lista de contraseñas. Aplicando Fuerza Bruta con crackmapexec, descubrimos a un usuario con una contraseña válida de la lista. Con estas nuevas credenciales, enumeramos el servicio RPC, en donde encontramos una contraseña en texto claro al mostrar la información de las impresoras activas. Usamos esa contraseña para aplicar Password Spraying a todos los usuari...
Una máquina sencilla, pero que tiene sus sorpresas. Analizando el escaneo de servicios, descubrimos algunos archivos del servicio FTP que dan a entender que utilizan este servicio como servidor web y que, además, podemos loguearnos en el servicio FTP como usuario anonymous. Dentro del FTP, subimos un archivo random y lo visualizamos en la página web, comprobando que todo lo que subamos al FTP, se verá representado en la página web. Aprovechamos esto, para subir un Reverse Shell de PHP con tal de obtener una sesión en la máquina víctima. Una vez conectados, descubrimos un archivo con un código extraño que resulto ser lenguaje Brainfuck. Decodificando ese código, descubrimos que es la contraseña de un usuario del servicio SSH. Ya dentro del SSH, encontramos un script de Python que convierte en base64 a cualquier texto y que se puede ejecutar como el usuario Root. Aprovechamos este script para aplicar Python Library Hijacking y Script Hijacking para escalar privilegios.
Fue una máquina sencilla que requiere un poquito de trabajo. Al descubrir solamente dos puertos abiertos, nos vamos a analizar la página web activa en el puerto 80. Al no encontrar mucho, aplicamos Fuzzing con lo que descubrimos una página que sirve como login. Dicha página, permite la ejecución de comandos desde el campo contraseña que aprovechamos usando BurpSuite para obtener una Reverse Shell. Dentro de la máquina, ubicamos y descargamos un archivo ZIP que logramos crackear, siendo que contiene la contraseña de un usuario de la máquina víctima. Convirtiéndonos en ese usuario, descubrimos que tiene privilegios para usar el comando apt de otro usuario de la máquina. Utilizando GTFOBins, logramos obtener una sesión como el segundo usuario de la máquina. Por último, dicho usuario también tiene privilegios sobre el binario aws del usuario Root que, de igual forma, logramos escalar privilegios usando GTFOBins y nos convertimos en Root.
Esta es una máquina que ocupa bastante talacha. Después de realizar los escaneos, vamos a analizar la página web que resulta tener un mensaje en el código fuente. Dicho mensaje nos manda a un directorio de la página web en donde descargamos un binario y un archivo DLL. Investigando y probando el binario, nos damos cuenta de que tenemos que aplicar Buffer Overflow. Realizamos esto utilizando Immunity Debugger, una máquina virtual Windows 7 y la Librería mona.py. Aplicando el Buffer Overflow, ganamos acceso a la máquina como el usuario Administrador.
Esta fue una máquina muy sencilla. Después de aplicar los escaneos, descubrimos únicamente 2 puertos abiertos, siendo el puerto 80 y puerto 22. Revisando la página web, encontramos un mensaje al final de la página, dándonos una pista de que debemos aplicar fuerza bruta al servicio SSH. Encontramos la contraseña y nos logueamos. Dentro, vemos que podemos usar el binario puttygen como Root. Investigando este binario, vemos que podemos crear nuevas llaves e inyectarlas dentro del directorio authorized_keys del usuario Root, con lo que podremos escalar privilegios.
Una máquina media que me hizo pensar bastante. Después de analizar los servicios, entramos en la página web activa y al no encontrar algo de utilidad, aplicamos Fuzzing para descubrir archivos y directorios ocultos, encontrando un archivo PHP que simulaba un login. Analizando este archivo, comenzamos a probar si es vulnerable a LFI, aplicando Fuzzing para encontrar un parámetro que se pudiera utilizar para esto. Encontrando un parámetro válido, aplicamos LFI para obtener la llave privada de un usuario, con la que nos podemos conectar a un contenedor en el puerto 2222. Dicho contenedor, tenía un archivo Excel (xlsm) que contenía las credenciales de un usuario del servicio SSH. Dentro del SSH, buscamos formas de escalar privilegios, encontrando un script y descubriendo que este es usado en una tarea CRON con pspy. Investigando un poco y analizando el script, encontramos que es vulnerable a inyecciones Wildcard, que aprovechamos para cambiar los permisos de la Bash para que tenga permisos SUID y con eso escal...
Esta fue una máquina bastante sencilla con la que pude probar varias cosillas. Después de aplicar los escaneos y al no encontrar una forma de enumerar sus servicios, aplicamos fuerza bruta al servicio FTP, encontrando un usuario y contraseñas válidos que nos permiten acceso a FTP y SMB. Dentro, descubrimos que usan el servicio FTP como un servidor para su página web, por lo que aprovechamos esto para cargar una WebShell de ASPX que nos permite ejecutar comandos. Aprovechamos esto para usar varios métodos que nos permiten ganar acceso a la máquina. Ya dentro y enumerando la máquina, descubrimos que es vulnerable a dos Exploits que nos permiten escalar privilegios, estos son: MS11-046 y MS15-051.
Esta fue una máquina fácil, pero que requiere bastante talacha(trabajo) para resolverla. Descubrimos que tiene una página web activa en el puerto 80 y tiene expuesto el servicio MySQL en el puerto 3306. Analizando y aplicando Fuzzing a la página web, descubrimos que fue realizada con WordPress. Buscando plugins vulnerables, encontramos que usa el plugin wpDiscuz que es vulnerable al permitir subida de archivos, por lo que realizamos dos formas de explotar esta vulnerabilidad. Aparte, aplicamos fuerza bruta al servicio MySQL que nos permite loguearnos y enumerar el servicio, encontrando las credenciales de un usuario con el que nos podemos loguear al servicio SSH. Dentro, encontramos un archivo ZIP que tuvimos que crackear para encontrar su contraseña. El archivo ZIP contenía archivos de KeePass a los que les aplicamos un volcado de memoria para obtener la contraseña maestra, pues ahí se encuentra la contraseña del Root.
Una máquina un poco difícil en cuanto a la intrusión, ya que si no sigues las pistas, puedes perderte. En los escaneos, identificamos que estamos contra un Directorio Activo e identificamos un servidor Jenkins. Enumeramos algunos servicios y el servidor Jenkins, antes de llegar al servicio SMB. Después de enumerar el servicio SMB, encontramos un archivo que contiene el nombre de un usuario y la pista en donde se encuentra su contraseña. Usando un Exploit dirigido a Jenkins, podemos aplicar LFI y con esto, logramos obtener la contraseña del usuario encontrado. Conectándonos a la máquina víctima con evil-winrm, identificamos que nuestro usuario tiene el privilegio SeImpersonatePrivilege, lo que nos permite usar Juicy Potato para escalar privilegios y convertirnos en Administrador. El problema es que no podremos ver las flags, a menos que cambiemos la contraseña del Administrador.
Esta fue una máquina un poco complicada. Al solo encontrar dos puertos activos, nos vamos al puerto 80 para analizar la página web. Al intentar registrar un nuevo usuario, descubrimos que no nos permite subir ninguna imagen, por lo que realizamos un sniper attack para descubrir qué extensiones ocupa. Una vez descubierta la extensión, subimos un archivo malicioso que nos permite obtener una Reverse Shell de la máquina víctima. Dentro, utilizamos el binario base64 para copiar la llave privada de un usuario, que crackeamos y obtenemos su contraseña para loguearnos en el servicio SSH. Dentro del SSH, encontramos un script de Python al que es posible aplicarle Python Library Hijacking para escalar privilegios.
Es una máquina bastante sencilla. Después de identificar los puertos y servicios, analizamos el servicio HTTP activo, en donde aplicamos Fuzzing para identificar directorios y archivos ocultos, siendo que encontramos un archivo que nos permite aplicar LFI. El LFI nos permite ver el /etc/passwd, con lo que identificamos un usuario perteneciente al servicio SSH al que le aplicamos fuerza bruta con distintas herramientas, descubriendo su contraseña. Ya dentro del servicio SSH, revisando los privilegios de nuestro usuario, podemos usar el comando find como Root, lo que nos permite escalar privilegios para obtener una sesión del Root, usando la guía de GTFOBins.
Una máquina bastante similar a la máquina Bounty de HTB. Después de descubrir el puerto 445 y el puerto 80, intentamos listar los recursos compartidos del servicio SMB, pero al no poder hacerlo, nos vamos al servicio HTTP al cual le aplicamos Fuzzing, así descubrimos una página que nos permite subir archivos. Aplicando un ataque Spider con BurpSuite, descubrimos que acepta archivos con extensión .config. Investigando, hay una forma de subir un archivo malicioso web.config que nos permite tener una CMD en una página web, misma que aplicamos, y así es como obtenemos una Reverse Shell. Por último, revisando los privilegios de nuestro usuario, tenemos el SeImpersonatePrivilege, lo que nos permite utilizar la herramienta Juicy Potato para escalar privilegios y convertirnos en Administrador.
Es una máquina algo complicada. Analizando los puertos activos, vemos uno en especial que resulta ser un servidor ejecutado por un binario que obtenemos del servicio FTP. Analizamos y hacemos pruebas de las funciones del binario, descubriendo que es vulnerable a Buffer Overflow, por lo que seguimos varios pasos para crear un script que, al ejecutarlo, obtenga una Reverse Shell de la máquina víctima. Dentro, descubrimos que se trata de un contenedor de Docker que está activo en el puerto 2222. Enumerando un poco, encontramos las credenciales de un usuario y una nota donde se nos indica que debemos analizar el tráfico de la red de la máquina. Haciendo lo pedido, obtenemos las credenciales de otro usuario, que nos permiten conectarnos al servicio SSH del puerto 22. Volviendo a enumerar, descubrimos el binario sudo con permisos SUID, pero al no hallar una forma de aprovecharnos de este, buscamos un Exploit para la versión de este binario y encontramos el CVE-2021-3156, que nos permite escalar privilegios para ...
Esta fue una máquina bastante complicada para mí. Empezamos descubriendo únicamente 2 puertos abiertos, yéndonos directamente a aplicar Fuzzing al servicio HTTP, donde descubrimos que están ocupando Joomla y una nota que indica que usan HTTP3 Quic para almacenar una página web. Utilizando quiche 0.16.0, aplicamos una petición a esta página para ver su contenido, dándonos una ruta que podemos ver en el navegador. Entrando a esa ruta, resulta ser una página que se encarga de ver archivos web internos, por lo que aplicamos el ataque SSRF para apuntar a archivos internos. Además, enumeramos el CMS Joomla con joomscan, descubriendo un archivo .bak que contiene las credenciales de un usuario para el servicio MySQL. Con lo descubierto, usamos gopherus para crear payloads de MySQL que enumeren este servicio y también modifiquen la contraseña del administrador del Joomla. Entrando a Joomla, modificamos la plantilla Protostar para obtener una CMD y así aplicamos una Reverse Shell con la que ganamos acceso inicial a ...
Una máquina bastante sencilla, que puede ser útil para practicar el reconocimiento y explotación de vulnerabilidades de WordPress, pues para ganar acceso a la máquina, tenemos que explotar una vulnerabilidad de WordPress que nos permitirá ejecutar comandos de manera remota. Una vez dentro de la máquina, podemos usar linPEAS para encontrar vulnerabilidades en el sistema, así encontramos un archivo de WordPress que tiene el usuario y contraseña de la base de datos de MySQL. Enumeramos MySQL y encontramos el hash de la contraseña de un usuario, la cual crackeamos y obtenemos acceso a la cuenta de este usuario. Por último, identificamos un proceso en segundo plano usando pspy64, siendo este el que usaremos para escalar privilegios y convertirnos en Root.
Esta fue una máquina sencilla. Empezamos analizando el servicio HTTP, ahí encontramos algunos nombres que después probamos con Kerbrute para poder ver qué usuarios existen en la máquina víctima, aunque también enumeramos el servicio LDAP con el que encontramos otro usuario. Al probar nuestra lista de usuarios, la volvemos a probar para poder aplicar el AS-REP Roasting Attack, con el que obtuvimos un hash TGT que crackeamos con JohnTheRipper y Hashcat, siendo de esta forma con la que ganamos acceso a la máquina vía WinRM. Una vez dentro, enumeramos la máquina y descubrimos que hay otro usuario del que no tenemos contraseña, por lo que usamos winPEAS para encontrar una vulnerabilidad que nos permita autenticarnos como ese nuevo usuario. De esta forma encontramos la contraseña en texto claro del nuevo usuario. Entrando a la máquina como el nuevo usuario, utilizamos BloodHound y SharpHound para descubrir una vía potencial para escalar privilegios, siendo que tenemos los permisos exactos para aplicar el DCSync ...
Esta fue una máquina bastante útil para practicar inyecciones SQL basadas en errores. Empezamos únicamente encontrando un puerto abierto, siendo una página web activa que analizamos y probamos su registro de usuarios. Al no encontrar nada más, aplicamos una inyección SQL que nos permitió ganar acceso a la página como un administrador, lo que nos permitió también descubrir el login de Flask Volt. Pero, al no tener una contraseña, enumeramos la base de datos de la página web a través de inyecciones SQL basadas en errores, descubriendo un hash de la contraseña del administrador, crackeamos el hash y ganamos acceso al login de Flask Volt. Analizando las funciones de Flask Volt, encontramos que es vulnerable a Server Side Template Injection (SSTI) y de esta forma, aplicamos una Reverse Shell para ganar acceso a la máquina. Dentro de la máquina, identificamos que es un contenedor de Docker y que tiene una montura de un usuario, ahí aplicamos un script de Bash que descubre los puertos y encontramos activo el puer...
Esta fue una máquina no tan difícil como esperaba, pero interesante en la forma de escalar privilegios. Empezamos por analizar la página web activa, pero al no encontrar nada útil, pasamos a enumerar los servicios activos, que el que más nos ayudó fue el servicio Kerberos, ya que usamos Kerbrute para obtener una lista de usuarios válidos a los que les aplicamos fuerza bruta, para ver si alguno de estos ocupa su mismo nombre de usuario como contraseña, siendo que si hayamos un usuario que hace esto. Gracias a este usuario, logramos obtener acceso al servicio MSSQL que tiene activado el comando xp_dirtree. Esto nos permitió enumerar algunos directorios locales de la máquina, encontrando así un backup en los archivos de la página web, dentro de la ruta /inetpub/wwroot. Dentro del backup, hay un archivo oculto que contiene la contraseña de otro usuario, que tiene acceso a WinRM y es el que usaremos para conectarnos a este servicio usando Evil-WinRM. Para enumerar el AD, ocuparemos adPEAS dentro de la sesión de...
Esta máquina sí fue algo sencilla. Todo se basó en la enumeración, empezamos enumerando el DNS para ver qué información obteníamos e intentamos aplicar el ataque de transferencia de zona sin éxito. Al solo encontrar el dominio y un subdominio, procedemos a enumerar el servicio SMB, lo cual descubrimos que es necesario de credenciales válidas para hacerlo. Pasamos a enumerar el servicio RPC, obteniendo una sesión nula que nos permitió enumerar usuarios y grupos. Utilizando esos usuarios obtenidos, aplicamos el AS-REP Roasting attack, con el que obtuvimos el hash del TGT de un usuario y desciframos su contraseña usando JohnTheRipper para obtenerla en texto claro. Gracias a esto, nos conectamos vía WinRM a la máquina víctima usando Evil-WinRM y procedemos a cargar PowerView.ps1 y SharpHound para poder enumerar la máquina usando BloodHound. Dentro de BloodHound, identificamos que nuestro usuario, tiene relación con el grupo Account Operators y tiene el privilegio GenericAll sobre el grupo Exchange Windows Perm...
Esta fue una máquina que para nada es fácil; hubo que hacer bastante investigación. Empezamos enumerando la página web, aquí encontramos que podemos subir archivos y luego visitarlos, y también podemos descargar un archivo ZIP que contiene un repositorio de Git que es igual a la página web. Nos aprovechamos de tener los archivos de la página web para descubrir una vulnerabilidad en su sanitización de archivos, lo que nos permite suplantar cualquier archivo existente de la página web. Además, descubrimos unas credenciales de un usuario al enumerar el repositorio de Git, encontrándolas en una rama anterior. Sabiendo esto, suplantamos un script que nos crea una Reverse Shell/Backdoor con la que podemos obtener una shell cada vez que lo visitemos. Haciendo más pruebas a la sanitización, descubrimos que es posible aplicar LFI, que esto nos ayuda más adelante. Aplicando Fuzzing, descubrimos una consola de Flask que sirve para debuggear errores, siendo necesario un PIN para su acceso, copiamos el proceso que crea...
Esta es una máquina que nos reta a probar varias formas de poder ganar acceso, pues por un ataque que sufrieron, se desactivó la autenticación NTLM, lo que nos complica la forma de explotar la máquina. Primero analizamos la página web, en donde encontramos información útil como la desactivación de la autenticación NTLM, un usuario, etc. Probamos a enumerar varios servicios, pero el que nos ayuda más es el servicio Kerberos. Al probar varias formas de ganar acceso a la máquina vía Kerberos, optamos por aplicar el Silver Ticket Attack con el que ganaremos acceso al servicio MSSQL como el usuario administrador de ese servicio. Gracias a los privilegios que tenemos, es posible que podamos usar el JuicyPotatoNG, pero si quieres ir por el camino difícil, enumeramos las bases de datos existentes, encontrando un usuario y su contraseña en texto claro. Podemos pivotear a otro usuario utilizando un binario netcat, que podemos cargar desde la sesión de MSSQL, siendo que podemos usarlo usando xp_cmdshell. Una vez dent...
Esta es una máquina que para nada es fácil, ya que hay muchos pasos y conceptos de Directorio Activo (AD) que deberías de tener claros para completar la máquina. Como en todo AD, nos basamos mucho en la enumeración, empezamos enumerando el servicio SMB. Esto nos permitió descubrir y obtener un archivo comprimido que contenía un binario, que debugueamos con DNSpy para obtener la contraseña en texto claro del servicio LDAP. Con esta contraseña, entramos al servicio LDAP y lo enumeramos, pero al no encontrar mucho, utilizamos la herramienta ldapsearch con la que encontramos otra contraseña en texto claro de un usuario, esto nos llevó a aplicar Password Spraying con crackmapexec para encontrar al usuario al que le pertenecía la contraseña. Una vez encontrado el usuario, ganamos acceso a la máquina conectándonos usando Evil-WinRM, adentro cargamos SharpHound para recopilar información del AD, la información obtenida la analizamos con BloodHound y así descubrimos una computadora que podía ser comprometida, aplic...
Es una máquina relativamente sencilla, comenzamos entrando al servicio HTTP, el cual nos pedirá credenciales para poder entrar, adivinamos las credenciales y enumerando el sitio web, encontramos que podemos subir archivos. La página acepta archivos SCF, podemos obtener un hash que contiene usuario y contraseña del protocolo SMB si cargamos un archivo SCF malicioso. Crackeando el hash con la herramienta JohnTheRipper nos conectamos de manera remota con Evil-WinRM al protocolo SMB y gracias a la herramienta WinPEAS, encontramos el proceso spoolv activo, que es vulnerable al Exploit CVE-2021-1675 - PrintNightmare LPE, siendo que podemos crear un usuario administrador nuevo y nuevamente con Evil-WinRM ganamos acceso como Administrador en la máquina Windows.
Esta fue una máquina, un poquito complicada, vamos a analizar varios servicios que tiene activo, siendo que el servicio HTTPS será la clave para resolver la máquina, pues podremos aplicar PostgreSQL Injection de dos formas, con BurpSuite y con SQLMAP para obtener una Shell de manera remota. Una vez dentro, descubrimos que estamos en una aplicación de varias, gracias a la herramienta Docker Toolbox que está usando, nos conectamos a la primera aplicación usando credenciales por defecto de esta herramienta y nos conectamos a una aplicación que copia todo el contenido de la máquina.
Esta fue una máquina bastante interesante, haciendo los escaneos correspondientes, únicamente, encontramos un puerto abierto que corre el servicio Telnet, al no encontrar nada más, buscamos por UDP y encontramos el puerto 161 donde corre el servicio SNMP. De ahí, encontramos la contraseña para acceder a Telnet y abusando de los privilegios, obtenemos una shell de forma remota. Para escalar privilegios, utilizamos el privilegio lpadmin y el CVE-2012-5519 para explotarlo y obtener la flag del Root.
Esta fue una máquina algo complicada, descubrimos que usa el servicio Tomcat para su página web y aplicamos Local File Inclusion (LFI) para poder enumerar distintos archivos como el /etc/passwd y logramos ver el tomcat-users.xml que tiene usuario y contraseña de un usuario de ese servicio. Utilizamos curl para subir una aplicación web tipo .WAR que contiene una Reverse Shell, dentro de la máquina copiamos en base64 un archivo .ZIP con el cual obtenemos la contraseña de un usuario. Por último, usamos el grupo LXD al que esta asignado un usuario para escalar privilegios usando un Exploit.
Esta es una máquina muy fácil, vamos a aprovecharnos de una vulnerabilidad en la versión de PHP 8.0.1-dev que nos permitirá conectarnos de manera remota como el usuario James, una vez dentro, vamos a investigar los privilegios que tenemos, encontrando que podemos usar el binario Knife, buscamos en la página GTFOBins y nos explica una forma para convertirnos en Root.
Esta fue una máquina un poco complicada, lo que hicimos fue analizar los campos/funciones de la página web, así encontramos que podemos utilizar el Exploit CVE-2020-7384 para conectarnos de manera remota a la máquina víctima, después de enumerar lo que había dentro como el usuario Kid, analizamos 2 scripts y las tareas CRON activas (esto con pspy) lo que nos permitira hacer pivoting para conectarnos a otro usuario llamado pwn, esto mediante inyección de comandos. El usuario pwn tendrá permisos para usar la consola de Metasploit, dentro de la consola, usaremos la terminal de Ruby para convertirnos en Root.
Esta fue una máquina bastante interesante, lo que hicimos fue analizar el servicio HTTP para descubrir que tienen un sistema de tickets y un servidor, a su vez usan Virtual Hosting por lo que registramos los dominios y aprovechamos un ticket creado que nos crea un correo temporal en OS Ticket (su sistema de tickets), con esto usaremos el servicio Mattermost para crear una cuenta con el fin de entrar a este servicio. Una vez dentro de Mattermost, vemos mensajes del Root, que nos indican el usuario y contraseña del servicio SSH, además nos dan una pista siendo que debemos ir a la base de datos de Mattermost dentro del servicio SSH para obtener el hash del Root, con esto podremos usar las reglas de hashcat para poder crear un diccionario y poder crackear el hash para autenticarnos como Root.
Esta máquina fue algo complicada para mí, porque se trató de un ejercicio de Active Directory. Tuve que investigar mucho sobre Active Directory, gracias a la herramienta smbclient y smbmap, se pudo enumerar el servicio SMB siendo que encontramos un archivo que contiene credenciales de usuario, esto nos permitirá hacer el ataque Kerberoasting para obtener credenciales de Root.
Esta es una máquina algo sencilla, vamos a usar Fuzzing a la página web que está activa en el puerto HTTP, como no descubrimos nada, buscaremos por archivos ASP, pues usa el servicio IIS y encontraremos una página para subir archivos. Utilizaremos BurpSuite para descubrir que archivos acepta, que en este caso serán los .config, usaremos un archivo web.config para cargar un Payload de Nishang .ps1, con esto accederemos a la máquina como usuarios. Para escalar privilegios, usaremos Juicy Potato, pues tiene los privilegios necesarios para utilizarlo.
Esta fue una máquina relativamente sencilla, investigaremos el puerto HTTP que con la ayuda de nmap y haciendo Fuzzing, encontramos una página que nos dara información valiosa como una llave privada en base hexadecimal. La desciframos, pero estara encriptada por lo que no nos servira hasta más adelante. Con la ayuda de nmap encontramos un Exploit llamado Heartbleed con el cual capturaremos data que nos ayudara a descifrar al fin la llave privada y nos dara una contraseña para el SSH, usando el Exploit CVE-2018-15473 pondremos nombres randoms y encontraremos un usuario con el cual entramos. Para escalar privilegios, usamos la herramienta Tmux, que encontramos en el historial de Bash y que nos metera a una nueva terminal como Root (CVE-2011-1496).
Esta fue una máquina bastante sencilla, en la que vamos a analizar el código fuente de la página web que está activa en el servicio HTTP para poder entrar en una subpágina que utiliza el servicio Nibbleblog. Haremos Fuzzing normal y ambientado a subpáginas PHP y encontraremos algunas a las cuales podremos enumerar. Una vez dentro, analizaremos el Exploit CVE-2015-6967 que nos indicara que podemos añadir una Reverse Shell hecha en PHP, para poder conectarnos de manera remota. Ya conectados, utilizaremos un script en Bash con permisos de SUDO para poder escalar privilegios como Root.
Una máquina realmente sencilla. Vamos a aprovecharnos de una subpágina que es una shell de bash como web, la cual vamos a usar para conectarnos de manera remota y en la cual, usaremos el usuario scriptmanager para escalar privilegios, usando un script en Python con él cambiaremos los permisos de la Bash para convertirnos en Root.
Una máquina bastante complicada, otra que debería ser nivel medio, más no fácil. Usaremos el servicio HTTP para poder encontrar una forma de ganar acceso a la máquina, siendo que el código fuente nos ayudara a encontrar un plugin llamado Bookingpress, con el cual nos apoyaremos para capturar una petición usando curl y mandándola a BurpSuite, para después poder enumerar la base de datos de la página con sqlmap, capturando las credenciales en forma de hashes. Una vez las descifremos, entraremos al login del WordPress y en base a la versión, vamos a usar el Exploit CVE-2021-29447 para cargar un Payload en formato .wav para que con PHP podamos descifrar las credenciales del servicio FTP que tiene la máquina. Adentro del FTP encontraremos las credenciales para el servicio SSH, nos logueamos como usuario y después de investigar que hay dentro de este servicio, usaremos Passpie para poder exportar la contraseña del Root.
Una máquina que debería ser de dificultad media porque fácil no fue, lo que hicimos fue registrar la página del servicio HTTP en el /etc/hosts, luego vamos a utilizar Fuzzing para descubrir un login, que nos muestra el servicio Tiny File Manager. Accederemos usando las credenciales por defecto de este servicio y cargaremos una Reverse Shell hecha en PHP en la carpeta Uploads del servicio para poder conectarnos de manera remota a la máquina. Dentro buscaremos el directorio del servicio Nginx para descubrir una subpágina, la cual nos permitirá crear un usuario y loguearnos en ella, dentro de esta subpágina encontraremos en el código fuente que usa un Web Socket, usaremos el ataque Blind SQL Injection para capturar las credenciales del usuario de la máquina. Una vez dentro de la máquina, usaremos la herramienta linpeas.sh para descubrir una forma de escalar privilegios, siendo que usaremos el programa Doas para que active un script que nosotros haremos que cambiara los privilegios de la Bash, para que cuando ...
Esta fue una máquina algo difícil, porque no sabía bien como acceder como usuario, trate de cargar un Payload, pero no funciono, estudie el ataque Smuggling para tratar de obtener credenciales, pero no lo entendí del todo bien, intente usar un Exploit para Ruby-on-rails, pero no funciono, por eso tarde bastante en resolverla. En fin, vamos a abusar de la herramienta que genera el el PDF que usa la página web de la máquina, llamado pdfkit, usaremos el Exploit CVE-2022-25765 para acceder a la máquina y robar las credenciales del usuario. Una vez conectados como usuario, abusaremos de un script de Ruby que tiene permisos de SUDO para inyectar código malicioso que nos permita escalar privilegios como root, esto en base al YAML Deserialization.
Esta fue una máquina que jugó un poco con mi paciencia porque utilicé Fuzzing para listar archivos en la página web para encontrar algo útil, que si encontré, pero se tardó bastante, mucho más que en otras máquinas por lo que tuve que distraerme un poco en lo que terminaba. En fin, se encontró información crítica como credenciales para acceder al servicio pfSense y se utilizó un Exploit CVE-2014-4688 para poder conectarnos de manera remota, siendo que nos conecta como Root, no fue necesario hacer una escalada de privilegios.
Esta fue una máquina algo compleja porque tuve que investigar bastante, pues al hacer los escaneos no mostraba nada que me pudiera ayudar. Sin embargo, gracias al Fuzzing pude encontrar una línea de investigación que me llevo a descubrir el ataque ShellShock, gracias a este podremos conectarnos de manera remota a la máquina y usando un archivo con privilegios Root, escalaremos privilegios.
Esta es una de las máquinas más sencillas que he hecho, pues no es mucho lo que tienes que hacer, aunque la investigación si me tomo algo de tiempo. Lo que haremos será usar credenciales por defecto del SO Raspberry Pi para entrar al SSH y con esto obtener las flags, lo único quizá difícil, es la forma de recuperar un .txt que fue eliminado. Igual, vamos a probar la forma de copiar el disco que tiene los archivos borrados y trataremos de recuperarlos en nuestra máquina.
Esta es una máquina bastante sencilla, en donde haremos un Fuzzing y gracias a este descubriremos archivos de Java, que al descompilar uno de ellos contendrá información critica que nos ayudará a loguearnos como Root. Además de que aprendemos a enumerar los usuarios del servicio SSH, es decir, sabremos si estos existen o no en ese servicio gracias al Exploit CVE-2018-15473. También nos aprovecharemos de Wordpress y PHPMyAdmin, para probar algunas formas de ganar acceso a la máquina.
Esta máquina fue algo difícil porque no pude escalar privilegios usando un Exploit sino que se usa un binario que automáticamente te convierte en Root, además de que tuve que investigar bastante sobre operaciones REGEX para poder filtrar texto. Aunque se ven temas interesantes como el ataque de transferencia de zona DNS y veremos acerca del virtual hosting que por lo que he investigado, hay otras máquinas que lo van a ocupar.
Esta fue una máquina fácil en la cual vamos a vulnerar el servicio HTTP del puerto 80 que está usando Microsoft IIS 6.0 WebDAV, usando un Exploit que nos conectara de forma remota a la máquina (CVE-2017-7269), de ahí podemos escalar privilegios a NT Authority System aprovechando que tenemos el privilegio SeImpersonatePrivilege, justamente usando Churrasco.exe (una variante de Juicy Potato para sistemas windows viejos) y utilizando un Payload.
Una máquina algo sencilla, vamos a vulnerar el servicio Adobe ColdFusion 8 usando el Exploit CVE-2009-2264 que nos conectara directamente a la máquina usando una Reverse Shell, entraremos como usuario y usaremos el Exploit MS10-059 para escalar privilegios y convertirnos en NT Authority System.
La máquina Optimum, bastante sencilla con varias formas para poder vulnerarla, en mi caso use el CVE-2014-6287 para poder acceder a la máquina como usuario, y para escalar privilegios utilice el Exploit MS16-032 y MS16-098.
Esta máquina es relativamente fácil, pues hay bastantes maneras de poder vulnerarla. Lo que haremos, será usar un Exploit que nos conecte de manera remota a la máquina, será configurado y modificado para que sea aceptado, pues la página web que esta activa en el puerto 443, tiene ya expirado su certificado SSL. Una vez dentro, usaremos los permisos que tenemos para convertirnos en Root usando la herramienta nmap tal y como lo menciona el Exploit usado.
Una máquina bastante sencilla, en la cual usaremos el servicio FTP para cargar un Payload que contendrá una Shell que se activará en el puerto HTTP que corre el servicio IIS y después escalaremos privilegios usando el Exploit MS11-046.
Una máquina no tan complicada, ya que vamos a utilizar un Exploit que ya hemos usado antes con la máquina Blue, la diferencia radica en los named pipes activos en el servicio Samba que está activo, hay varias manera de aprovecharnos de este, vamos a probar 3 diferentes..
Esta máquina es algo difícil, pues hay que investigar todos los servicios que usa y ver de cual nos podemos aprovechar para poder vulnerar los sistemas de la máquina, además de analizar los Exploits, estos se deben configurar correctamente para su uso. Nos aprovechamos del servicio NSF para poder crear una montura y así obtener la contraseña para entrar al servicio Umbraco, una vez dentro encontramos que el Umbraco usa la versión 7.12.4 que es vulnerable a ejecución remota de comandos, por lo que cargamos una Reverse Shell que nos conecta a la máquina usando un Exploit de esta versión de Umbraco. Dentro logramos escalar privilegios de varias formas como explotando el servicio TeamViewer, cambiando el servicio UsoSvc, usando Juicy Potato y con un módulo de Metasploit.
Esta es una máquina un poco más dificil que las anteriores, siendo que para poder entrar a la máquina por el servicio SSH usaremos BurpSuite para obtener las credenciales desde la página web aplicando varias inyecciones XXE, una vez dentro nos aprovecharemos de los permisos sobre un script en Python para poder escalar privilegios como root, aquí el análisis de código es vital y de suma importancia, pues debemos saber algo de Python y desarrollo web o al menos entender lo que hacen ciertas partes de la máquina.
Una máquina relativamente fácil, ya que usamos un Exploit muy conocido que hace juego con el nombre de la máquina y que hay una historia detrás de su obtención, siendo que este Exploit supuestamente fue robado a la NCA. Haremos uso del famoso Exploit Eternal Blue para ganar acceso como un usuario administrador, aprovecharemos para utilizar otras herramientas para obtener información sobre el servicio SMB y la máquina.
Esta es una máquina fácil que usa Windows y en la cual vamos a vulnerar el servicio SMB que está abierto en uno de los puertos a través de la enumeración del servicio FTP y de una vulnerabilidad en el servicio PRTG Network Monitor que nos permite inyectar código en dicho servicio, lo que nos va a permitir crear un usuario con privilegios de administrador siendo de esta forma en la que escalamos privilegios.
Esta es una máquina bastante sencilla realizada en Windows y en la cual vamos a usar el servicio Tomcat para poder ganar acceso, nos autenticaremos usando credenciales que nos muestra el servicio Tomcat al momento de fallar la autentiacación, observamos que se pueden subir archivos tipo .WAR a este servicio, por lo que vamos a usar un Payload en lugar de usar un Exploit para crear una Reverse Shell que nos conecte a la máquina al ejecutar este archivo malicioso, no será necesario escalar privilegios ya que una vez conectados seremos el usuario administrador y obtendremos las flags.
La máquina lame es una de las primeras maquinas que hice, justo después del Starting Point, obviamente necesité mucha ayuda porque había cosas que aún no comprendía del todo. Es una maquina super fácil, ya que lo único que haremos será utilizar el servicio Samba para poder obtener acceso a la máquina.
En esta ocasión, voy a mostrar unas cosillas que nos pueden ser útiles para nuestras pruebas de penetración. Puedes probarlas cuando estés en HackTheBox, VulnHub, TheHackersLabs e incluso, en Active Directory.
Lo que haremos en esta ocasión, será resolver todos los niveles que se encuentran en la sección Bandit, esto como práctica de pentesting en entornos Linux.
Esta fue una máquina bastante sencilla. Después de aplicar un descubrimiento de hosts, identificamos nuestro objetivo y comenzamos las pruebas de penetración. Se identifica que el servicio SMB es vulnerable al ataque Eternal Blue, por lo que se hacen distintas pruebas para aplicar este ataque, siendo que únicamente se pudo aplicar con la herramienta Metasploit Framework. Además, se hace un ataque de fuerza bruta con crackmapexec para obtener las contraseñas de los usuarios registrados, pero no fue exitoso. Una vez que obtenemos la sesión de meterpreter, podemos cargar el módulo Kiwi que nos permite usar mimikatz para obtener las contraseñas y hashes NTLM de los usuarios. Por último, buscamos y leemos el archivo Unattend.xml en busca de la contraseña del usuario Administrador, pero no estaba en el archivo, por lo que damos por concluida la máquina.
En esta ocasión, vamos a analizar una captura de entorno y los paquetes que podemos obtener cuando un dispositivo se conecta a una AP, analizaremos cada paquete que trabaja en este proceso con tal de entender un poco el funcionamiento de cada paquete y como estos nos pueden ayudar a identificar dispositivos y APs que estan en constante comunicación.
Esta es una reseña (sin muchos spoilers) sobre el examen para la certificación eCPPTv3. Explicaré un poco de qué trata la certificación, cómo fue el curso de preparación que imparte INE Security y mi opinión sobre este, y una reseña del examen que me toco realizar. Además, añadiré algunos tips y consejos que te pueden ser útiles para realizar el examen.Si vas a aplicar el examen, ¡mucha suerte y éxito!.
Esta es una reseña sobre la certificación eJPTv2, explicaré un poco (sin dar spoilers) sobre el examen y más que nada del curso al que tienes acceso solo si lo compras junto a la certificación en paquete. Además compartiré algunos consejos y links que te pueden servir a la hora que presentes el examen. Si vas a aplicar el examen, ¡mucha suerte y éxito!.