Sicurezza $_GET e $_POST (validare tutto)

[Shinji 89]

Salve sono 2 giorni che leggo in giro sul web pillole e guide sulla sicurezza delle variabili ma non sono riuscito ancora a capire cosa usare nel mio caso:

- La mia applicazione non prevede l'inserimento di nessun testo da parte dell'utente (solo numeri) e l'unico testo che uso nelle variabili $GET/$POST è per specificare che azione deve essere compiuta nella pagina (es. $_GET[mode]= canella/visualizza/processa/ecc. anche parole accentate) e non viene inserito dall'utente .

Quindi morale a parte il recasting nelle query per le varibili volevo capire che funzioni utilizzare per validare le variabili passate via GET e POST, che a parte addslashes non sono riuscito ancora a capire quelle che dovrei usare (html_entities,htmlspecialchars,ecc.)

Per validare in un colpo solo tutte le varibili GET/POST vorrei utilizzare questo codice:

<?php
function add_slashes ($an_array) {
  foreach ($an_array as $key => $value) {
    $new_array[$key] = addslashes($an_array[$key]);
  }
}
add_slashes($_POST); 
add_slashes($_GET);
add_slashes($_REQUEST);
?>

Tenete conto che non posso modificare il php.ini in nessun modo(register_globals,magic_quotes_gpc sono su on), e che ho letto la guida di questo sito.

[filippo.toso]

Originariamente inviato da Shinji 89
- La mia applicazione non prevede l'inserimento di nessun testo da parte dell'utente (solo numeri) e l'unico testo che uso nelle variabili $GET/$POST è per specificare che azione deve essere compiuta nella pagina (es. $_GET[mode]= canella/visualizza/processa/ecc. anche parole accentate) e non viene inserito dall'utente .

Crea un array whitelist con i valori abilitati ed utilizza quello per validare l'input.

La soluzione che stai adottando (add_slashes()) va contro il processo di sviluppo del PHP visto che riproduce il funzionamento delle Magic Quotes, deprecate da PHP 5.3.0 e rimosse da PHP 6.0.0

[Shinji 89]

ecco cosa mancava al primo post asd...avevo dimenticato di dire che non posso farlo perchè le variabili sono troppe. Cosa dovrei usare a questo punto ? (la versione di php è comunque 4)

[buribus]

Visto che nemmeno fornisce sufficienti garanzie, ritengo anche io che l'utilizzo di add_slashes() deve essere evitato; inoltre la tendenza generale è quella di cercare di utilizzare del codice non obsoleto, prima o poi dovranno aggiornare PHP anche sul tuo server e nella creazione di un'applicazione è bene considerarne anche la futura compatibilità.

Secondo me dipende tutto dall'utilizzo che ne fai nel tuo codice delle variabili $GET/$POST, e soprattutto dal tipo di valore che ti aspetti di riceverne.
nel caso di un intero $id = (int)$GET['id'];
nel caso delle stringhe, ma è una indicazione fin troppo generale, una bella passata di html_entities ti mette spesso al sicuro da spiacevoli sorprese oltre ad assicurare un corretto encoding di apici e caratteri speciali.

sempre per le stringhe ancora diverso è il discorso se le variabili sono passate per effettuare una queri su un database, nel qual caso bisogna utilizzare particolare accortezza per farlo in modo sicuro. nel caso di Mysql, direi che usare mysql_real_escape_string() sulle variabili prima di utilizzarle in qualunque operazione (lettura, scrittura, update e delete) è una buona pratica.

Su un argomento così cruciale eppur trascurato da tanti è sempre gradito da parte mia un confronto con gli altri utenti.

[Shinji 89]

Quindi al posto di addsleshes mi consigli di usare soltanto html_entities nella funzione che ho citato sopra ?

PS Ho trovato questo codice che sembra simulare addsleshes mi consigliate di integrarlo al suo posto?

$search = array("&", "\"", "'", "\\", "<", ">");
$replace = array("&amp;", "&quot;", "'", "\", "&lt;", "&gt;");
 
$var_post = count($_POST);
$keys = array_keys($_POST);
for ($i=0; $i<$var_post; $i++)
    $_POST = str_replace($search, $replace, $_POST);
 
$var_post = count($_GET);
$keys = array_keys($_GET);
for ($i=0; $i<$var_post; $i++)
$_GET = str_replace($search, $replace, $_GET); 

[LeaderGL]

Una buona pratica, secondo me, sarebbe quella di:
1) utilizzare un array di parametri "aspettati" indicando anche la loro lunghezza massima ed il loro tipo;
2) passare questo array ad una funzione di "filtraggio" degli input alla quale si indica anche la provenienza
3) questa funzione, che prende due array in input(GET/POST/etc e l'array dei parametri aspettati) filtra le corrispondenze in base alle informazioni che gli passiamo.

In genere si lavora con classi o comunque con delle funzioni, quindi i parametri che ci aspettiamo e che useremo sono in numero limitato, è ragionevole quindi una situazione di questo tipo:

function parse_input($source, $expected) {
    $result = array();
    foreach ( $expected AS $parameter => $type ) {
        if ( isset($source[$parameter]) ) {
            switch ( $type ) {
                case 'bool':
                    $result[$parameter] = settype($source[$parameter], 'boolean'); break;
                case 'integer':
                    $result[$parameter] = settype($source[$parameter], 'integer'); break;
                case 'float':
                case 'double':
                    $result[$parameter] = settype($source[$parameter], 'float'); break;
                case 'string':
                    $result[$parameter] = mysql_real_escape_string($source[$parameter]); break;
                default:
                    $result[$parameter] = htmlentities($source[$parameter]); break;
            }
        }
    }
    return $result;
} 

da utilizzare in questo modo:

function myFunction() {
    $expected = array
        (
            'id'    =>    'integer',
            'nome'    =>    'string',
            'testo'    =>    'string'
        );
        
    $get = parse_input($_GET, $expected);
    
    // il resto del codice
} 

ovviamente la funzione "parse_input()" va resa più robusta e la si può comunque personalizzare per tipi nuovi (es. 'mysql', 'date', etc).

che ne dite?

[Shinji 89]

trovo la tua funzione molto utile ma come ho detto in precedenza non ho la possibilità di usare whitelist di variabili...vorrei semplicemente capire dato la mia applicazione quali funzioni mi conviene usare per sicurezza e visto che ci sono faccio un ricapitolo...

<?php
function add_slashes ($an_array) {
  foreach ($an_array as $key => $value) {
    $new_array[$key] = htmlentities(($an_array[$key]); // ho cambaito addslash con htmlentities
  }
}
add_slashes($_POST);
add_slashes($_GET);
add_slashes($_REQUEST);
?>

Ora visto che mi consigliate di non usare addsleshes stavo chiedendo se a questo punto andava bene il codice seguente che simula addslashes:

$search = array("&", "\"", "'", "\", "<", ">");
$replace = array("&", "&quot;", "&#39;", "\", "&lt;", "&gt;");

$var_post = count($_POST);
$keys = array_keys($_POST);
for ($i=0; $i<$var_post; $i++)
    $_POST = str_replace($search, $replace, $_POST);

$var_post = count($_GET);
$keys = array_keys($_GET);
for ($i=0; $i<$var_post; $i++)
$_GET = str_replace($search, $replace, $_GET); 

Infine una volta assodato se l'ultimo pezzo di codice mi conviene usarlo o meno. Tolto il recasting delle variabili per query, mysql_real_escape_string(), c'è qualche altra funzione/metodo che dovrei usare per validare i dati passati via GET/POST ?

[LeaderGL]

io penso che tra "addslashes()" ed una funzione che simula "addslashes()" ci sia poca differenza in termini di sicurezza.

Il problema è che quando noi usiamo un dato dobbiamo essere sicuri che sia di quel tipo, che abbia un ben determinata lunghezza massima e che ci ponga al sicuro da PHP Injections, SQL Injections e, se quello che ci arriva in ingresso lo stampiamo a video, anche da attacchi XSS.

Tutto questo dal semplice e generico "addslashes()" e simili non viene fatto e dovrebbe essere fatto dal programmatore che utilizza i vari parametri; per questi motivi sono più per la soluzione che ho postato io (ovviamente migliorata) che per le altre due...

[LeaderGL]

Scusate mi sono accorto di aver scritto una castroneria riguardo l'uso di "settype()"...

Questo è il codice corretto:

function parse_input($source, $expected) {
    $result = array();
    foreach ( $source AS $key => $value ) {
        if ( is_array($value) ) {
            $result[$key] = parse_input($value, $expected[$key]);
        } else {
            if ( isset($expected[$key]) ) {
                switch ( $expected[$key] ) {
                    case 'bool':
                    case 'boolean':
                        settype($value, 'boolean'); break;
                    case 'int':
                    case 'integer':
                        settype($value, 'integer'); break;
                    case 'float':
                    case 'double':
                        settype($value, 'float'); break;
                    case 'mysql':
                    case 'string':
                        $value = mysql_real_escape_string($value); break;
                    default:
                        $value = htmlentities($value); break;
                }
                $result[$key] = $value;
            } else {
                $result[$key] = addslashes($value);
            }
        }
    }
    return $result;
} 

e questo un esempio, semplice, d'uso:

function myFunc($in) {
    $expected = array(
        'id'    =>    'integer',
        'nome'    =>    'string',
        'text'    =>    'string',
        'arr'    =>    array (
            'ar1'    =>     'integer',
            'ar2'    =>     'integer',
            'ar3'    =>    'string'
        )
    );
    $get = parse_input($in, $expected);

    print "<pre>";
    print_r($get);
    print "</pre>";
}

$in = array(
    "id"    =>    "7dsf",
    "nome"    =>    "Albert'o",
    "text"    =>    "Oggi sono andato all'albergo sul \"mare\"",
    "arr"    =>    array(
        "ar1"    =>    "0",
        "ar2"    =>    "3'''4930",
        "ar3"    =>    "prrrr'annzo\'\'\'o"
    )
);
myFunc($in); 

ad ogni modo è sicuramente migliorabile...

[k.b]

Per come la vedo io non esiste un sistema universale che vada bene in ogni caso. Piu' "universale" e' il metodo di filtraggio, meno e' sicuro e capillare. In sostanza bisogna valutare caso per caso in base ai tipi di dati che ti aspetti. Chiaramente la soluzione piu' sicura e' la whitelist, ma non e' sempre applicabile. La seconda scelta e' definire cosa e' accettabile (soluzione preferibile al definire cosa invece e' bandito): ad esempio, se il dato in ingresso e' uno username si puo' controllare che contenga solo caratteri alfanumerici con ctype_alnum(), se ci si attende un numero si puo' controllare che lo sia invece di usare un type cast e cosi' via. E' molto meglio rifiutare dati non conformi alle attese piuttosto che cercare di aggiustarli.

Inoltre dipende anche dall'uso che si deve fare dei dati in ingresso. Se cio' che viene da un $_POST dev'essere inserito in un database, non ha molto senso usare htmlentities() o simili: il codice html non e' in se' pericoloso se passato a un DB, quello deve essere filtrato come OUTPUT non come input. In quel caso piuttosto ha piu' senso usare strip_tags() perche' i casi sono due: o ti interessa il codice html (ma non ha senso registrarlo nel db gia' lavorato, lo registri cosi' com'e' e lo filtri quando lo invii in output al client) oppure il codice non ti interessa e allora non ha senso conservarlo.

Il tutto ovviamente IMHO