php security exploit con le immagini GIF

[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