PHP upload security

En este artículo vamos a ver como programar aplicaciones seguras en PHP para la subida de archivos. Este paper está basado en el publicado por Alla Bezroutchko de "SCANIT the Security Company" en el año 2007. Como siempre, trataré de adaptarlo para que los más neófitos en la programación en PHP lo entiendan sin problemas. No obstante, cualquier problema podéis postearlo y será atendido.

La subida de archivos en la web es algo que está a la orden del día, no sólo en aplicaciones webmail para adjuntar archivos, sino también en servidores de alojamiento de imágenes, documentos de texto, pdf's, videos, etc. Para que una aplicación PHP sea segura, tenemos que atender siempre a las variables de entrada (y en ocasiones, también a las de salida!). A lo largo del paper iremos viendo diferentes aplicaciones PHP con filtros para evitar el upload de archivos dañinos y sus correspondientes bypasses. Finalmente se mostrará una forma segura de programar una aplicación no vulnerable al upload de archivos así como distintas medidas de seguridad alternativas. Si a tí, estimado lector, se te ocurre alguna forma mejor ó consideras que las expuestas aquí no son lo suficiente seguras, me encantaría que compartieras con todos nosotros tu forma de securizar las aplicaciones.

0.- Breves consideraciones:

Cuando utilizamos una aplicación PHP para subir un archivo, se crea un array superglobal que se almacena en la variable global _FILES. Antíguamente se utilizaba HTTP_POST_VARS, que aunque sigue estando disponible, ha ha caído para muchos programadores en el desuso en pro de la anterior. El array que se crea es similar a este:

Código:

Array
(
[attachment] => Array
(
[name] => imagen.jpeg //Nombre del archivo
[type] => image/jpeg //Tipo de archivo
[tmp_name] => /tmp //Directorio temporal en el que se almacenará el archivo
[error] => 0 //tipo de error
[size] => 1234 //tamaño del archivo
)
)

Y es que cuando subimos un archivo a un servidor, primero se almacena en un directorio temporal y posteriormente la aplicación lo mueve al directorio que había previsto el programador para ser almacenado. De todos estos valores, tenemos que tener cuidado con name y type porque son los únicos que tienen como origen el propio usuario ya que los demás son asignados por el servidor. Estos valores son por tanto variables de entrada que deben ser atendidas con especial atención si no queremos que nos cuelen una shell.php.

1.- Aplicación básica:

Vamos a ver una aplicación muy elemental que carece de medidas de seguridad. A partir de ahora, todas estas pruebas las puedes hacer tú en tu servidor local. Tan sólo crea una carpeta llamada "images" en el directorio raíz del servidor y asignale permisos necesarios para el usuario Nobody, que es el ocupado por Apache.

Código:

chmod -R 777

Veréis que utilizo la función is_uploaded_file() para verificar si el archivo ha sido subido. La explicación es que es necesario saber si se ha subido el archivo antes de moverlo a su directorio final porque si no se verifica y el archivo ha sido subido, podría engañarse a la aplicación spoofeando el formulario y cambiando el name='button' por name='foo' por ejemplo. Esto no movería el archivo de su directorio temporal a su directorio final, lo que nos podría permitir (dependiendo de la configuración del httpd.conf) acceder al directorio temporal. Nuestro servidor estará seguro si para los parámetros <directory /> tenemos Options FollowSymLinks y AllowOverride None. Importante no tener la opción Indexes habilitada para evitar que se expongan directorios que puedan resultar sensibles por unas razones u otras.

Código:

<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>

Para probar, sólo tenéis que guardar el código que tenemos a continuación como upload.php y subirlo al directorio raíz de vuestro servidor.

Código

<html>
<head>
<meta http-equiv='Content-type' Content='charset UTF-8'>
<title>Aplicación básica</title>
<body>
<center>
<h2>Uploader de imágenes</h2>
<FORM method="POST" ENCTYPE="multipart/form-data" action='upload.php'>
<INPUT type='file' name='archivo'>
<INPUT type='submit' name='button' value='Enviar'>
</FORM>
<?php
$dir= 'images/';
if (isset ($_POST['button']) && is_uploaded_file($_FILES['archivo']['tmp_name'])){
$file= $dir.basename($_FILES['archivo']['name']);
move_uploaded_file($_FILES['archivo']['tmp_name'], $file);
}
?> 
</body>
</html>

Veamos la comunicación que ha tenido lugar entre nuestro navegador y el servidor:

Código:

Host: localhost
User-Agent: Mozilla/5.0 (X11; U; Linux i686; es-ES; rv:1.9.1.5) Gecko/20091105 Fedora/3.5.5-1.fc11 Firefox/3.5.5
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: es-es,es;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive: 300
Connection: keep-alive
Referer: http://localhost/upload.php
Content-Type: multipart/form-data; boundary=---------------------------1022791273854029891036475525
Content-Length: 381

-----------------------------1022791273854029891036475525\r\n
Content-Disposition: form-data; name="archivo"; filename="shell.php"\r\n
Content-Type: application/octet-stream\r\n
\r\n
<?php\n
system($_GET['cmd']);\n
?>\n
\r\n
-----------------------------1022791273854029891036475525\r\n
Content-Disposition: form-data; name="button"\r\n
\r\n
Enviar\r\n
-----------------------------1022791273854029891036475525--\r\n

Bypassing básico:

¿Bypassing? No hay nada qué bypassear. Sólo sube tu shell.php y listo.

2.- Verificación por Content-Type:

El protocolo HTTP, como muchos otros protocolos de red, utiliza una serie de variables en sus cabeceras a las que asigna un valor. Content-Type es una de ellas e indica el tipo de contenido del recurso. Una medida de seguridad podría ser verificar el Content-Type de la cabecera del paquete para cerciorarnos de que efectivamente se está tratando de subir una imagen. Supongamos una aplicación uploadct.php que sólo permita subir imágenes con extensión *.gif y *.jpeg:

Código

<html>
<head>
<meta http-equiv='Content-type' Content='charset UTF-8'>
<title>Aplicación por Content-Type</title>
<body>
<center>
<h2>Uploader de imágenes</h2>
<FORM method="POST" ENCTYPE="multipart/form-data" action='uploadct.php'>
<INPUT type='file' name='archivo'>
<INPUT type='submit' name='button' value='Enviar'>
</FORM>
<?php
$dir= 'images/';
if (isset ($_POST['button']) && is_uploaded_file($_FILES['archivo']['tmp_name'])){
if ($_FILES['archivo']['type'] != "image/gif" && $_FILES['archivo']['type'] != "image/jpeg"){
echo "<script>alert('Archivo no permitido!')</script>";
}else{
$file= $dir.basename($_FILES['archivo']['name']);
move_uploaded_file($_FILES['archivo']['tmp_name'], $file);
}
}
?> 
</body>
</html>

Bypassing Content-Type:

El bypassing de este mecanismo de seguridad es muy sencillo. Basta con coger nuestra shell.php y renombrarla a shell.jpg. De esta forma el servidor verá que _FILES['archivo']['type']=='image/jpeg' por lo que dejará subir la aplicación. Pero ¿qué hacemos con esto? ¿de qué nos sirve subir una shell con extensión de imagen?. Ahí está la gracia del bypass. Este es uno de los ataques más comunes a formularios de subida de imágenes ó al menos, es del que he visto más videotutos por la red. La ídea es modificar la cabecera del paquete, dejando tal cual el Content-Type pero modificando la extensión del archivo que estamos subiendo. Podéis ver un ejemplo de cómo hacerlo con Live-HTTP-Headers:

De tal manera, la extensión de nuestro archivo es .php, por lo que nuestro script podrá ser ejecutado sin ayuda de ningún LFI. Esto lo habremos conseguido como ya he dicho, bypasseando el filtro _FILES['archivo']['type'] vía modificación del apartado (Content-Type) de la cabecera del paquete HTTP.

2.- Verificación por getimagesize() ó exif_imagetype():

PHP incluye una función llamada getimagesize() que nos revela datos informativos sobre un archivo de imagen. Por el contrario de lo que pueda parecer a simple vista, no sólo nos revela el tamaño de la imagen, también nos revela infomación sobre el tipo de imagen vía parámetro: imageinfo. Al utilizar esta función, se genera el siguiente array:

Código:

Array[0] = Width
Array[1] = Height
Array[2] = Image Type Flag
Array[3] = width="xxx" height="xxx"
Array['bits'] = bits
Array['channels'] = channels
Array['mime'] = mime-type

De aquí nos interesa ['mime'], que nos dirá el tipo de imagen que es. ¿Qué ocurre si intentamos subir una shell.jpg? Sencíllamente, verificando con getimagesize() el índice del array 'mime' no nos dejará subir ningún archivo que no tenga la estructura propia de una imagen. Un ejemplo de uploading sería el siguiente:

Código

<html>
<head>
<meta http-equiv='Content-type' Content='charset UTF-8'>
<title>Aplicación getimagesize</title>
<body>
<center>
<h2>Uploader de imágenes</h2>
<FORM method="POST" ENCTYPE="multipart/form-data" action='uploadgis.php'>
<INPUT type='file' name='archivo'>
<INPUT type='submit' name='button' value='Enviar'>
</FORM>
<?php
$dir= 'images/';
if (isset ($_POST['button']) && is_uploaded_file($_FILES['archivo']['tmp_name'])){
$imaginf= getimagesize($_FILES['archivo']['tmp_name']);
if ($imaginf['mime'] != "image/gif" && $imaginf['mime'] != "image/jpeg"){
echo "<script>alert('Archivo no permitido!')</script>";
}else{
$file= $dir.basename($_FILES['archivo']['name']);
move_uploaded_file($_FILES['archivo']['tmp_name'], $file);
}
}
?> 
</body>
</html>

Otra función que PHP incorpora es exif_imagetype(). Al pasarle un input, genera una constante que puede ser del siguiente tipo:

Código:

1 IMAGETYPE_GIF
2 IMAGETYPE_JPEG
3 IMAGETYPE_PNG
4 IMAGETYPE_SWF
5 IMAGETYPE_PSD
6 IMAGETYPE_BMP
7 IMAGETYPE_TIFF_II (intel byte order)
8 IMAGETYPE_TIFF_MM (motorola byte order)
9 IMAGETYPE_JPC
10 IMAGETYPE_JP2
11 IMAGETYPE_JPX
12 IMAGETYPE_JB2
13 IMAGETYPE_SWC
14 IMAGETYPE_IFF
15 IMAGETYPE_WBMP
16 IMAGETYPE_XBM

Comparando el resultado con la constante, es muy fácil saber si el archivo que se está subiendo es una imagen o por el contrario no:

Código

<html>
<head>
<meta http-equiv='Content-type' Content='charset UTF-8'>
<title>Aplicación getimagesize</title>
<body>
<center>
<h2>Uploader de imágenes</h2>
<FORM method="POST" ENCTYPE="multipart/form-data" action='uploadeit.php'>
<INPUT type='file' name='archivo'>
<INPUT type='submit' name='button' value='Enviar'>
</FORM>
<?php
$dir= 'images/';
if (isset ($_POST['button']) && is_uploaded_file($_FILES['archivo']['tmp_name'])){
$imaginf= getimagesize($_FILES['archivo']['tmp_name']);
if (exif_imagetype($_FILES['archivo']['tmp_name']) != IMAGETYPE_GIF && exif_imagetype($_FILES['archivo']['tmp_name']) != IMAGETYPE_JPEG){
echo "<script>alert('Archivo no permitido!')</script>";
}else{
$file= $dir.basename($_FILES['archivo']['name']);
move_uploaded_file($_FILES['archivo']['tmp_name'], $file);
}
}
?> 
</body>
</html>

Para hacer las pruebas en vuestro entorno local, tan sólo tenéis que renombrar los ejemplos como uploadgis.php y uploadeit.php respectivamente.

Bypassing getimagesize() y exif_imagetype():

Por el contrario de lo que pueda parecer, cualquiera de estas aplicaciones son fáciles de bypassear. Hace tiempo, Codebreak mostró una forma de infectar mediante LFI y la inserción de código PHP en los comentarios de las imágenes. De esta forma, con un simple LFI y un upload de imágenes en el servidor se podía ejecutar código PHP. Esto es perfectamente aplicable a este caso. La aplicación verificará que efectivamente se trata de una imagen pero al tener extension PHP, el servidor interpretará el código del comentario de la imagen y tomará la demás parte del archivo como basura, por lo que no lo tendrá en cuenta. Insertar comentarios en imágenes se puede hacer de muchas maneras, por comando type de windows, con un editor de imágenes como GIMP, etc. Veremos como hacerlo desde GIMP:

Abrimos la imagen, vamos a Imagen-->Propiedades de la imagen y en el apartado comentario insertamos el código PHP:

En el ejemplo del GIMP he utilizado una imagen pelota.jpeg. Para que se ejecute habrá que renombrarla a pelota.jpeg después de haber insertado el comentario. Una vez subida, podremos hacer cosas como esta:

Verificación por extensión:

La verificación por extension no es otra cosa que una verificación de tipo de archivo por extension del nombre del mismo. Existen diversas formas de verificar por archivo. Hace tiempo ya creó OzX un post en Undersecurity.net en el que varios usuarios fuimos poniendo nuestra propia forma de reconocer un archivo. Pongo a continuación los ejemplos y el autor:

Ozx:

Código

<?php
 
$testcase = array("sample.txt", "sample.jpg", "sample.case.txt");
 
function extension($filename){
    return substr(strrchr($filename, '.'), 1);
}
 
foreach($testcase as $test) {
    echo "Extension from $test is " . extension($test) . "\n"; 
} 
 
?>

SH4V:

Código

<?php
$archivo=array("archivo.txt","archivo.jpeg","archivo.rb.txt",
"archivo.html","archivo.php.txt");
 
foreach ($archivo as $name){
$ext=explode(".",$name);
$num=count($ext)-1;
echo "Extensión para $name: $ext[$num]<br>";
}
?>

Seth:

Código

<?php
 
$testcase = array("sample.txt", "sample.jpg", "sample.case.txt.jpg");
 
function extension($filename){
    $path_parts = pathinfo($filename);
    return $path_parts['extension'];
}
 
foreach($testcase as $test) {
    echo "Extension from $test is " . extension($test) . "\n"; 
} 
 
?>

C1c4Tr1Z:

Código

<?php
$files=array("example.php", "new_example.log", "third.txt", "something.asp", "another_thing.js");
foreach($files as $file){
	$extention;
	if((preg_match('/(?:[\.]+([a-z0-9]{2,3}))$/i', $file, $extention))){
		echo "$file -> {$extention[1]}\n";
	}
}
?>

WHK (elhacker.net):

Código

<?php
$files=array("example.php", "new_example.log", "third.txt", "something.asp", "another_thing.js", 'x..jpeg');
foreach($files as $file){
	$extention;
	if((preg_match('/(?:[\.]+([a-z0-9]{2,3}))$/i', $file, $extention))){
		echo "$file -> {$extention[1]}\n";
	}
}
?>

Bypassing por extensión de archivo:

Una verificación por extension evitaría subir en teoría subir código de riesgo a la carpeta de uploads. Sin embargo existen metodos para poder burlarla como los LFI (Local File Inclusion) que aprovechan las funciones:

Código

include()
include_once()
require()
require_once()

No entraré a explicar los LFI. Puedes encontrar un número elevado de textos si buscas por la red un poco.

Solución:

La mejor solución bajo mi punto de vista sería utilizar una mezcla de todas. Veamos un ejemplo de uploader seguro en el que se deberan de pasar varios filtros. Si se pasa el primer filtro, deberá pasarse el siguiente y así sucesivamente. Finalmente si se pasan todos los filtros la imagen se renombrará con un nombre aleatorio de 15 caracteres y su extensión correspondiente. Esta aplicación no nos protegería de una imagen con código PHP incrustado en los comentarios y extensión de imagen. Así que ¡¡CUIDADO CON LOS LFI!!

Código

<html>
<head>
<meta http-equiv='Content-type' Content='charset UTF-8'>
<title>Aplicación segura</title>
<body>
<center>
<h2>Uploader de imágenes</h2>
<FORM method="POST" ENCTYPE="multipart/form-data" action='uploadsec.php'>
<INPUT type='file' name='archivo'>
<INPUT type='submit' name='button' value='Enviar'>
</FORM>
<?php
 
$dir= 'images/';
 
if (isset ($_POST['button']) && is_uploaded_file($_FILES['archivo']['tmp_name'])){
$file= basename($_FILES['archivo']['name']);
	if ($_FILES['archivo']['type'] != "image/gif" && $_FILES['archivo']['type'] != "image/jpeg"){
	echo "<script>alert('Archivo no permitido! El archivo no es una imagen.')</script>";
	}elseif(exif_imagetype($_FILES['archivo']['tmp_name']) != IMAGETYPE_GIF && exif_imagetype($_FILES['archivo']['tmp_name']) != IMAGETYPE_JPEG){
	echo "<script>alert('Archivo no permitido! Se intentó subir un archivo envenenado.')</script>";
	}else{
	$name=$dir.substr(md5(rand()), 15, 30).extension($file);
	move_uploaded_file($_FILES['archivo']['tmp_name'], $name);
	}
}
?> 
</body>
</html>

Un método propuesto por WHK, de elhacker.net, para la validación del nombre del archivo es este:

Código

<?php
$nombrearchivo = 'test../../&$%;,(xx)-_-(xx)[]*\\n.jpg';
$nombrearchivo = str_replace(array(
 "\x00", '*', '\\', '/', ':', '?', '¿', '<', '>', '|', '&', ',', ';'
), '', $nombrearchivo);
echo $nombrearchivo;
exit;
?>

También sería oportuno asignar unos valores en el php.ini a las variables:

Código:

- upload_max_filesize
- post_max_size
- upload_tmp_dir

Para validar otros archivos que no sean imágenes, podemos usar fileinfo del repositorio PECL. Para ello tendremos que instalar Pear.Una vez instalado Pear, podemos instalar la librería de la siguiente manera:

Código:

pear install fileinfo

Después podemos hacerla correr añadiéndola como extensión al php.ini:

Código:

extension=fileinfo.so

ó en el propio script:

Código

<?php dl(“fileinfo.” . PHP_SHLIB_SUFFIX);?>

Para verificar el tipo de archivo se puede utilizar de dos maneras. La primera nos mostraría una descripción del tipo de archivo y la segunda sólo el tipo de archivo:

Código

<?php 
finfo_file(finfo_open(), “documento.pdf”);//muestra una descripción del tipo de archivo
finfo_file(finfo_open(FILEINFO_MIME), “documento.pdf”);//muestra el tipo de archivo
?>

Si alguien considera que esta aplicación no es segura del todo ó que hay alguna errata ó conoce alguna forma mejor de programarla, que postee en los comentarios su aporte y será añadio y se harán las correcciones oportunas. Toda crítica constructiva es bienvenida.

Gr33tz:

Agradecimientos a Pr0x, Protos, Lix, OzX, Yasión, Seth, Nork, S[e]C, N0b0dy, 1995, C1c4Tr1Z, WHK y a todos los miembros de Undersecurity y N3t-Datagrams.

Ejemplos:

http://n3t-datagrams.net/downloads/phpuploadsexamples.tar.gz

FUENTE:

http://n3t-datagrams.net/docs/?/=15

Saludos!