php security exploit con le immagini GIF

[equiweb.it]

Ciao a tutti,
ho letto di un possibile exploit sfruttando le immagini gif caricate dagli utenti ( http://www.phpclasses.org/blog/post/...IF-images.html )

mi sono sorte però alcune domande...
conviene davvero utilizzare questa tecnica, leggere lei mmagini con readfile appesantisce di molto il server?
il problema è riservato alle immagini gif oppure anche jpg ecc?


ciao e grazie a tutti

[filippo.toso]

E' sufficiente creare uno script di upload che VIETI di caricare file con delle estensioni che possono essere interpretate dal web server (es. php, php3, phtml, pl, cgi etc.).

[daniele_dll]

equiweb, il problema non è tanto quello, infatti, in generale, se riesci ad inviare un file con estensione .php e lo script che lo riceve, scusatemi il termine, ingenuamente lo tiene col suo nome, beh, la frittata e certa

di solito io faccio le seguenti cose:
- una volta ricevuto il file verifico l'estensione finale per vedere se è tra quelli ammessi
- in base all'estensione dichiarata apro il file se serve ridimensionamento
- se il primo ed il secondo step vanno bene, prendo l'estensione ammessa e copio il file in una cartella usando un hash (generato da sha1(uniqid(microtime(), true)) )
- inserisco il riferimento nel db

a questo punto, se mi serve spedire l'immagine, leggo dal db l'hash e il mime type e lo spedisco all'utente finale tramite un ciclo che legge chunk da 8kb e li spedisce tramite echo

ovviamente, in questo caso, è fondamentale spegnere l'output buffering

[equiweb.it]

Originariamente inviato da daniele_dll
equiweb, il problema non è tanto quello, infatti, in generale, se riesci ad inviare un file con estensione .php e lo script che lo riceve, scusatemi il termine, ingenuamente lo tiene col suo nome, beh, la frittata e certa

di solito io faccio le seguenti cose:
- una volta ricevuto il file verifico l'estensione finale per vedere se è tra quelli ammessi
- in base all'estensione dichiarata apro il file se serve ridimensionamento
- se il primo ed il secondo step vanno bene, prendo l'estensione ammessa e copio il file in una cartella usando un hash (generato da sha1(uniqid(microtime(), true)) )
- inserisco il riferimento nel db

a questo punto, se mi serve spedire l'immagine, leggo dal db l'hash e il mime type e lo spedisco all'utente finale tramite un ciclo che legge chunk da 8kb e li spedisce tramite echo

ovviamente, in questo caso, è fondamentale spegnere l'output buffering

perfetto...dunque sono "abbastanza" tutelato,quando faccio l'upload controllo sia l'estensione che il mime-type ed effettuo il ridimensionamento...

ora mi manca da implementare il sistema dell hash.

un ultima info:
per leggere a chunk di n kb io ho sempre utilizzato una funzione trovata su php.net che dovrebbe anche evitare prblemi con l'output buffering... secondo voi potrebbe andare?
ho provato a pensare altre soluzioni, ma questa mi sembra la più semplice e comoda...

// [url]www.php.net/readfile[/url]

function readfile_chunked($filename,$retbytes=true) { 
   $chunksize = 1*(1024*1024); // how many bytes per chunk 
   $buffer = ''; 
   $cnt =0; 
   // $handle = fopen($filename, 'rb'); 
   $handle = fopen($filename, 'rb'); 
   if ($handle === false) { 
       return false; 
   } 
   while (!feof($handle)) { 
       $buffer = fread($handle, $chunksize); 
       echo $buffer; 
       ob_flush(); 
       flush(); 
       if ($retbytes) { 
           $cnt += strlen($buffer); 
       } 
   } 
       $status = fclose($handle); 
   if ($retbytes && $status) { 
       return $cnt; // return num. bytes delivered like readfile() does. 
   } 
   return $status; 

} 

ciao e grazie mille

[filippo.toso]

La funzione http://www.php.net/readfile utilizza già un buffer di 8 Kb per la lettura/invio dei file che legge.

Se vuoi disabilitare l'output buffering prima di inviare i file tramite http://www.php.net/readfile è sufficiente utilizzare http://www.php.net/ob_end_flush

[equiweb.it]

grazie mille davvero!
nella documentazione di readfile non avevo trovato il fatto che leggesse a chunk di 8 kb...

grazie ancora delle dritte!

[daniele_dll]

Originariamente inviato da filippo.toso
La funzione http://www.php.net/readfile utilizza già un buffer di 8 Kb per la lettura/invio dei file che legge.

Se vuoi disabilitare l'output buffering prima di inviare i file tramite http://www.php.net/readfile è sufficiente utilizzare http://www.php.net/ob_end_flush

da quello che ho letto sui commenti, però direttamente non ho provato, c'è scritto che è abbastanza più lenta della lettura tramite codice php

più tardi faccio qualche test, per lo più per curiosità personale

Originariamente inviato da equiweb.it
un ultima info:
per leggere a chunk di n kb io ho sempre utilizzato una funzione trovata su php.net che dovrebbe anche evitare prblemi con l'output buffering... secondo voi potrebbe andare?
ho provato a pensare altre soluzioni, ma questa mi sembra la più semplice e comoda...

// [url]www.php.net/readfile[/url]

function readfile_chunked($filename,$retbytes=true) { 
   $chunksize = 1*(1024*1024); // how many bytes per chunk 
   $buffer = ''; 
   $cnt =0; 
   // $handle = fopen($filename, 'rb'); 
   $handle = fopen($filename, 'rb'); 
   if ($handle === false) { 
       return false; 
   } 
   while (!feof($handle)) { 
       $buffer = fread($handle, $chunksize); 
       echo $buffer; 
       ob_flush(); 
       flush(); 
       if ($retbytes) { 
           $cnt += strlen($buffer); 
       } 
   } 
       $status = fclose($handle); 
   if ($retbytes && $status) { 
       return $cnt; // return num. bytes delivered like readfile() does. 
   } 
   return $status; 

} 

ciao e grazie mille

ho scritto al volo questa funzione, dagli un occhio

<?php

function sendfile($FileName, $MimeType = false, $Disposition = 'attachment' /** attachment **/, $Name = false, $ChunkSize = 8096)
{
    /**
     * Verifica se il file esiste
     */
    if (file_exists($FileName) === false)
    {
        trigger_error("{$FileName} doesn't exists", E_USER_ERROR);
        return false;
    }

    /**
     * Invia gli headers ai browser
     */
    header('Cache-Control: no-cache, must-revalidate, post-check=0, pre-check=0');
    header('Expires: Mon, 26 Jul 1997 00:00:01 GMT');
    header('Content-Description: Downloading '  . basename($FileName) .  ' file');
    header('Content-Length: ' . filesize($FileName));
    header('Content-Disposition: ' . $Disposition .'; size=' . filesize($FileName) . '; filename=' . ($Name !== false ? $Name : basename($FileName)) . '');

    /**
     * Verifica se è stato passato il mime type
     */
    if ($MimeType === false)
    {
        /**
         * Verifica se esistono le funzioni relative all'estensione FileInfo per
         * verificare se questa è presente. Se tutto va correttamente inizializza
         * l'estensione e restituisce il mime type
         */
        if (function_exists('finfo_open') === false)
        {
            trigger_error("Unable to get mime type for {$FileName}, FileInfo extension is missing", E_USER_ERROR);
            return false;
        }

        if (($finfoHandle = finfo_open(FILEINFO_MIME)) === false)
        {
            trigger_error("Unable to initialize FileInfo extension, check FileInfo configuration", E_USER_ERROR);
            return false;
        }
        $MimeType = finfo_file($finfoHandle,$FileName);
        finfo_close($finfoHandle);
        unset($finfoHandle);
    }
    else
    {
        /**
         * Spedisce il mime type inviato
         */
        header('Content-type: ' . $MimeType);
    }

    /**
     * Apre il file
     */
    if (($fp = fopen($FileName, 'rb')) === false)
    {
        trigger_error("Cannot open {$FileName}", E_USER_ERROR);
        return false;
    }

    /**
     * Invia il file a blocchi di 8 KB
     */
    while($buffer = fread($fp, $ChunkSize))
    {
        echo $buffer;
        unset($buffer);
    }
    
    /**
     * Chiude l'handle del file
     */
    fclose($fp);
    return true;
}

sendfile('due.jpg', 'image/jpeg');

?>

Una cosa utile che gli manca è la risoluzione del mime type nel caso questo non sia passato e non sia presente l'estensione fileinfo. In quella che uso di solito, che ho a lavoro, ho una classe e all'interno di questa classe ho inserito un metodo che in base all'estensione prova ad acquisire il mime type ... ovviamente quel codice viene richiamato come ultima soluzione

La funzione che ti ho postato permette anche di definire il tipo di relazione tra la pagina chiamata ed i dati ricevuti, ovvero l'header Content Disposition che di default setto su inline, ovvero indica al browser di visualizzare il contenuto.

Il content-disposition settato su attachment indica invece al browser di far scaricare il tutto e non di mostrarlo a video se può

Il codice l'ho testato un po con firefox non ho provato con altri browser

[equiweb.it]

urca!
grazie mille!!! sei stato davvenro gentile!

se poi fai i test... facci sapere il risultato...è interessante come discorso!

una domanda... ma è davvero necessario inviare questi header nel caso di una immagine?

 header('Cache-Control: no-cache, must-revalidate, post-check=0, pre-check=0'); 
    header('Expires: Mon, 26 Jul 1997 00:00:01 GMT'); 
    header('Content-Description: Downloading '  . basename($FileName) .  ' file');

mi spiego meglio:
non è vantaggioso se il browser effettua una copia cache? in questo modo la prossima volta non farà nuovamente una richiesta al server...magari imposto come scadenza un mese dopo...
per le immagini bisogna forzare il download?


ciaooo e grazie ancora

[filippo.toso]

Gli header di gestione della cache sono solitamente utilizzate quando si inviano al client dei dati generati dinamicamente che non si vuole vegano salvati nella cache. Nel tuo caso puoi utilizzarli per forzare il salvataggio nella cache e ridurre il carico del server.

[daniele_dll]

beh conviene dire al browser di non salvare la cache perché dato che stai spedendo le immagini tramite php non vai a spedire anche le informazioni relativa alla data di creazione/modifica del file e l'e-tag