Vagando por la red, pude observar un upload realizado en PHP totalmente vulnerable a WebShell, la verdad no es sorpresa para mi por que yo implemente este Upload en PHP hace mucho tiempo por cierto en el año 2009 en un sitio web sobre desarrollo web y programación el cual yo administraba, y la cual fue atacado por dr.militan-53! de Zone-H.org.

El mirror que indexo zone-h es este: simpleforo.com hacked by dr.militan-53!.

Como todo newbie, subí el upload y no analice del todo el código del archivo y no pude fijarme pues me realizaron un deface un WebShell supongo.

Empecemos

Pero hoy no estoy para recordar viejos tiempos, hoy expongo aquí una forma de atacar y de prevenir este tipo de hackeo, Bien voy a utilizar un servidor maligno utilizado para robo y almacenamiento de datos de imágenes y cuentas de un juego online que actualmente tiene 48.73 GB de espacio utilizado, en realidad pura shit es lo que hay allí pero no soy quién para juzgar, bueno solo le quedan 3.97 GB un (8.15%) de espacio libre, entonces pronto lo dejaremos limpiecito.

El servidor es este: http://190.93.130.109
El upload se ubica en: http://190.93.130.109/Fotos/upload.php

Ahora voy a introducir una WebShell muy popular que pueden descargar desde aquí llamada: C99Shell v. 1.0, por cierto esta codificada en base64 para que no la detecte ningún antivirus, muy bien, voy a subir la WebShell y nos muestra lo siguiente:

Ahora voy a dirigirme a editar el archivo index.php y defacear el servidor, al realizar esta acción voy a dejar mi huella marcada en el servidor, pueden verla accediendo desde aca http://190.93.130.109, muy bien ahora que tengo control total voy a eliminar todos los archivos malignos y no malignos que este servidor contenga, como dije antes voy a limpiar todo, solamente dejaré el index defaceado y la carpeta dónde se ubica el upload para que puedan verlo, editare el upload para que no se afanen ustedes jaja.

Ahora selecciono los archivos a eliminar, como pueden ver contenia archivos ejecutables probablemente malignos de algún servidor de un juego online:

Elimine todos los archivos seleccionados y solamente nos quedo nuestro index.php y la carpeta Fotos que contenía el Upload PHP vulnerable, ya hemos concluido con el hackeo de este servidor.

Un vídeo

Prevención

El upload php unijimpe Vulnerable

Este upload acepta archivos PHP y permite ejecutarlos facilmente, aca pueden ver un Exploit PHP upload - (unijimpe) Remote File Upload Vulnerability, claramente se puede ver que también acepta WebShell transformadas en imágenes ejemplo: shell.php.pjpeg.

Por suerte existe una solución y una forma de añadir seguridad desde este artículo que preparo Unijimpe en su blog: Seguridad en Upload de Archivos.

Pasos preventivos

Los pasos que se pueden seguir son:

El archivo subido nunca debe ser accesible inmediatamente por el cliente.
Generar nombres aleatorios a los archivos subidos.
Filtrar los archivos para no permitir archivos PHP.
Subir los archivos a carpetas fuera del directorio de publicación.
Utilizar is_uploaded_file para verificar que el archivo se ha subido.
Utilizar move_uploaded_file para copiar el archivo al directorio final.

En el caso de imágenes

Verificar el Content-Type del archivo para asegurarse que el archivo es una imagen.
Verificar si el archivo es imagen con la función getimagesize.
Limitar el archivo a un máximo de tamaño.

Implementado Clase PHP para Upload

Siguiendo las reglas que hemos mencionado hemos creado una pequeña clase que facilita el subir archivos, Entonces se crea un archivo llamado upload.php donde se incluya el siguiente código:

// file: upload.php
// author: http://blog.unijimpe.net
// date: 27/02/2010
class Upload {
    var $maxsize = 0;
    var $message = "";
    var $newfile = "";
    var $newpath = "";
   
    var $filesize = 0;
    var $filetype = "";
    var $filename = "";
    var $filetemp;
    var $fileexte;
   
    var $allowed;
    var $blocked;
    var $isimage;
    var $isupload;
   
    function Upload() {
        $this->allowed = array("image/bmp","image/gif","image/jpeg","image/pjpeg","image/png","image/x-png");
        $this->blocked = array("php","phtml","php3","php4","js","shtml","pl","py");
        $this->message = "";
        $this->isupload = false;
    }
    function setFile($field) {
        $this->filesize = $_FILES[$field]['size'];
        $this->filename = $_FILES[$field]['name'];
        $this->filetemp = $_FILES[$field]['tmp_name'];
        $this->filetype = mime_content_type($this->filetemp);
        $this->fileexte = substr($this->filename, strrpos($this->filename, '.')+1);
       
        $this->newfile = substr(md5(uniqid(rand())),0,8).".".$this->fileexte;
    }
    function setPath($value) {
        $this->newpath = $value;
    }
    function setMaxSize($value) {
        $this->maxsize = $value;   
    }
    function isImage($value) {
        $this->isimage = $value;
    }
    function save() {
        if (is_uploaded_file($this->filetemp)) {
            // check if file valid
            if ($this->filename == "") {
                $this->message = "No file upload";
                $this->isupload = false;
                return false;
            }
            // check max size
            if ($this->maxsize != 0) {
                if ($this->filesize> $this->maxsize*1024) {
                    $this->message = "Large File Size";
                    $this->isupload = false;
                    return false;
                }
            }
            // check if image
            if ($this->isimage) {
                // check dimensions
                if (!getimagesize($this->filetemp)) {
                    $this->message = "Invalid Image File";
                    $this->isupload = false;
                    return false;   
                }
                // check content type
                if (!in_array($this->filetype, $this->allowed)) {
                    $this->message = "Invalid Content Type";
                    $this->isupload = false;
                    return false;
                }
            }
            // check if file is allowed
            if (in_array($this->fileexte, $this->blocked)) {
                $this->message = "File Not Allowed - ".$this->fileexte;
                $this->isupload = false;
                return false;
            }
                   
            if (move_uploaded_file($this->filetemp, $this->newpath."/".$this->newfile)) {
                $this->message = "File succesfully uploaded!";
                $this->isupload = true;
                return true;
            } else {
                $this->message = "File was not uploaded please try again";
                $this->isupload = false;
                return false;
            }
        } else {
            $this->message = "File was not uploaded please try again";
            $this->isupload = false;
            return false;
        }
    }   
}

Esta clase contiene:

setFile: nombre del campo del formulario que deseamos subir.
setPath: carpeta donde se guardará el archivo.
setMaxSize: permite definir el tamaño máximo del archivo (opcional).
isImage: permite definir si se hará verificación de imágenes.
save: guarda el archivo en la carpeta de destino.

Dos propiedades útiles:

isupload: devuelve verdadero o falso indicando si el archivo se ha subido.
message: devuelve un mensaje indicando que ocurrió en el proceso.

¿Como utilizar?

Creamos un formulario con un campo llamado "archivo" y adicionalmente un campo oculto que lo utilizaremos para verificar que el formulario se ha enviado. El siguiente paso es incluir el archivo al inicio de nuestro script, luego creamos una instancia de la clase, definimos la carpeta donde se guardarán los archivos, el nombre del campo y procedemos al upload del archivo. Esta clase implementa algunos puntos para asegurar nuestros scripts, pero efectivamente no es completamente seguro ya que hay varias técnicas de como penetrar como se explica en Secure file upload in PHP web applications.

Puede descargar el upload desde aquí.

Recomendaciones Adicionales

Lo que unijimpe recomienda es lo siguiente:

Cambiar el titulo de la página "PHP upload - unijimpe", los atacantes hacen una busqueda de esta palabra y pueden ubicar las páginas que utilizan este script el cual puede ser atacado. Entonces si vas a utilizar el script de upload por lo menos hay que cambiar el título al ejemplo descargado.
Otra sugerencia es no mostrar el archivo recién subido, el administrador debe revisarlo antes que sea publicado.
Agregar la validación por content-type, por la extensión del archivo como hemos mencionado en este post.
Filtrar los archivos y solo permitir los archivos necesarios.

Más información
Puedes obtener más información complementaria desde estos enlaces:

Atacando servidor - Vulnerabilidad PHP Upload unijimpe (Ataque y Prevención)