PHP upload security

SH4V · 11 Diciembre 2009, 11:30 AM

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 [Seleccionar]

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 [Seleccionar]

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 [Seleccionar]

<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 (php) [Seleccionar]

<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 [Seleccionar]

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 (php) [Seleccionar]

<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 [Seleccionar]

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 (php) [Seleccionar]

<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 [Seleccionar]

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 (php) [Seleccionar]

<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) [Seleccionar]

<?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) [Seleccionar]

<?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) [Seleccionar]

<?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) [Seleccionar]

<?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) [Seleccionar]

<?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 (php) [Seleccionar]

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 (php) [Seleccionar]

<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) [Seleccionar]

<?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 [Seleccionar]

- 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 [Seleccionar]

pear install fileinfo

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

Código [Seleccionar]

extension=fileinfo.so

ó en el propio script:

Código (php) [Seleccionar]

<?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) [Seleccionar]

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

Azielito · 11 Diciembre 2009, 21:46 PM

mas post de esos!

ñ_ñ'

Para los comentarios se me ocurre....

abrir el JPG como archivo de texto, y si se encuentran las cadenas

"<?" , "<?php" , "system(", "excec(" [y todas sus variantes xD] ",?>"
( aun que seguro basta con "<?" y "?>" )
si encuentra alguna de esas cadenas no pasa el archivo y/o se eliminan

Por cierto, usa las etiquetas [code=php] para colorear el codigo

yasión · 11 Diciembre 2009, 22:03 PM

Nice job SH4V!

Pues no se me ocurre nada más a mí... Cómo dices hay que vigilar los LFIs.

WHK · 11 Diciembre 2009, 22:55 PM

Hola se ve super bueno.

En la función de C1c4Tr1Z te limita de dos a tres carácteres de extensión, yo le pondría 2 a 4 ya que dejas afuera las extensiones con 4 carácteres como el .jpeg o el tiff.

Código (php) [Seleccionar]

<?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";
	}
}
?>

Yo preferiría utilizar preg_replace() para la eliminación de carácteres no soportados por el sistema operativo en el nombre de archivos y directorios tales como /\*?<>%00 etc.

La función pathinfo() que utilizó Seth me gustó mas porque utilizas una función nativa de php ahorrando el recurso de utilizar dos o mas funciones como lo hizo ozx para verificar una extensión o haciendo explode que al final da casi lo mismo en rendimiento.

Yo pienso que si vas a renombrar el nombre del archivo de la imagen para guardarla entonces está demás la verificación de la extensión ya que las misma función de exif_imagetype() es el corazón encargado de verificar que el archivo sea realmente de tipo imagen y php elimina de forma automática todos los archivos subidos de esta manera (hablo de los temporales) asi que veo innecesario la eliminación.

Como dijeron en el documento, si puedes hacer bypass a exif_imagetype() con el comentario del jpg tal como lo hacían antiguamente con el editjpgcom entonces buscaría otra solución como por ejemplo la utilización de GD para obtener la imagen desde el archivo sin importar su extensión con imagecreatefromstring(file_get_contents($file)) y luego hacer un imagepng() de salida como nuevo archivo evitando la inserción de comentarios y strings que puedan servir de inyección a nuestro servidor web.

Con esto te evitas utiliza exif_imagetype() y el case o loop para verificar el tipo de archivo y le das una @ al comienzo de la función de GD por si la imagen cargada no es una imagen válida.
También hay formas de procesar transparencias y animaciones con GD.

Para procesar el nombre del archivo yo creo que es otro tema, puedes mantener el mismo o puedes cambiarselo por uno al azar, yo en lo personal preferiría mantenerselo filtrando posibles incompatibilidades de carácteres y posibles ataques como por ejemplo

Código (php) [Seleccionar]

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

Y con respecto a la extensión preferiría utilizar pathinfo() como dijo seth. De todas formas si tu servidor tiene LFI eso ya es otro tema porque ni si quiera necesitas subir un archivo para ejecutar código arbitrario, basta con infectar el log de acceso o cualqueir tipo de log al cual se tengaa acceso aunque sea de solo lectura.

Ahora, para las descargas es otro tema también super interesante para evitar la descarga arbitraria de archivos locales, etc.

Este es mi comentario y crítica constructiva solamente xD el documento está super bueno de todas formas, lo agregaré al post de recopilatorios.

saludos.

SH4V · 12 Diciembre 2009, 13:02 PM

WoW! gracias WHK¡

Ahora mismo edito el post. Sobre el unlink()del archivo después de terminarse el request tienes toda la razón, es absurdo ya que PHP lo elimina del directorio temporal y de la tabla de hashes.

Te añado a los greetz por tus aportes =)

wisehacks · 12 Diciembre 2009, 13:43 PM

Muy bueno sh4van3. ¿Sabes si los framework de ASP.NET te implementan directamente este tipo de protecciones? Cuando tenga tiempo me pondré a jugar con ASP.NET y ya que te veo puesto en uploads pues te pregunto

SH4V · 12 Diciembre 2009, 13:53 PM

Actualizado!

Cita de: wisehacks en 12 Diciembre 2009, 13:43 PM
Muy bueno sh4van3. ¿Sabes si los framework de ASP.NET te implementan directamente este tipo de protecciones? Cuando tenga tiempo me pondré a jugar con ASP.NET y ya que te veo puesto en uploads pues te pregunto

Pues no lo sé wisehacks¡ para serte sincero, a día de hoy no tengo ni idea de ASP-net. Lo siento! Sé en frameworks como RoR (ahí sí que me manejo algo más) sí que te brindan este tipo de protecciones aunque siempre quedan agujeros de seguridad.

Saludos!

ChElAnO · 20 Diciembre 2009, 08:04 AM

muy bueno el post,

espero sigas realizando este tipo de material,

saludos!

ChElAnO

toxeek · 20 Diciembre 2009, 22:36 PM

Ala!

Que casualidad!

http://www.acunetix.com/websitesecurity/upload-forms-threat.htm

/*** MOD ***/

imagino que los de Acunetix se habran basado en el mismo paper que el tuyo ?!

Muy buen aporte por cierto :_)

temporal12345 · 21 Diciembre 2009, 05:07 AM

bueno el post, creo que solo faltaría quitar permisos de ejecución al directorio dónde se suben los archivos, y error_reporting(0).