Come posso disinfettare l'input dell'utente con PHP?

StackOverflow https://stackoverflow.com/questions/129677

Domanda

Esiste da qualche parte una funzione catchall che funziona bene per disinfettare l'input dell'utente per l'iniezione SQL e gli attacchi XSS, pur consentendo alcuni tipi di tag HTML?

È stato utile?

Soluzione

È un'idea sbagliata comune che l'input dell'utente possa essere filtrato. PHP ha anche un (ora deprecato) & Quot; feature & Quot ;, chiamato virgolette magiche, che si basa su questa idea. Non ha senso. Dimentica il filtro (o la pulizia o come la chiamano le persone).

Quello che dovresti fare, per evitare problemi, è abbastanza semplice: ogni volta che incorpori una stringa in un codice esterno, devi evitarlo, secondo le regole di quella lingua. Ad esempio, se si incorpora una stringa in alcuni SQL destinati a MySql, è necessario evitare la stringa con la funzione di MySql per questo scopo (mysqli_real_escape_string). (O, nel caso di database, l'uso di dichiarazioni preparate è un approccio migliore, quando possibile)

Un altro esempio è HTML: se si incorporano stringhe all'interno del markup HTML, è necessario evitarlo con <= > . Ciò significa che ogni singola istruzione htmlspecialchars o echo deve utilizzare print.

Un terzo esempio potrebbe essere i comandi di shell: se si intende incorporare stringhe (come argomenti) in comandi esterni e chiamarle con exec , quindi devi utilizzare escapeshellcmd e escapeshellarg .

E così via e così via ...

Il caso solo in cui è necessario filtrare attivamente i dati è se si accetta input preformattato. Per esempio. se consenti ai tuoi utenti di pubblicare markup HTML, che prevedi di visualizzare sul sito. Tuttavia, dovresti essere saggio per evitarlo a tutti i costi, poiché non importa quanto bene lo filtri, sarà sempre una potenziale falla di sicurezza.

Altri suggerimenti

Non tentare di impedire l'iniezione SQL disinfettando i dati di input.

Invece, non consente l'utilizzo dei dati nella creazione del codice SQL . Usa istruzioni preparate (ovvero utilizzando parametri in una query modello) che utilizza variabili associate. È l'unico modo per essere garantito contro l'iniezione SQL.

Si prega di consultare il mio sito web http://bobby-tables.com/ per ulteriori informazioni sulla prevenzione dell'iniezione SQL.

No. Non è possibile filtrare genericamente i dati senza alcun contesto a cosa servono. A volte vorresti prendere una query SQL come input e a volte vorresti prendere HTML come input.

Devi filtrare l'input in una whitelist: assicurati che i dati corrispondano ad alcune specifiche di ciò che ti aspetti. Quindi devi scappare prima di usarlo, a seconda del contesto in cui lo stai usando.

Il processo di escape dei dati per SQL - per impedire l'iniezione SQL - è molto diverso dal processo di escape dei dati per (X) HTML, per prevenire XSS.

PHP ha ora le nuove simpatiche funzioni filter_input, che per esempio ti liberano dal trovare "il regex di posta elettronica definitivo" ora che esiste un tipo FILTER_VALIDATE_EMAIL incorporato

La mia classe di filtro (utilizza javascript per evidenziare i campi difettosi) può essere avviata tramite una richiesta Ajax o un normale post di modulo. (vedi l'esempio sotto)      

/**
 *  Pork.FormValidator
 *  Validates arrays or properties by setting up simple arrays. 
 *  Note that some of the regexes are for dutch input!
 *  Example:
 * 
 *  $validations = array('name' => 'anything','email' => 'email','alias' => 'anything','pwd'=>'anything','gsm' => 'phone','birthdate' => 'date');
 *  $required = array('name', 'email', 'alias', 'pwd');
 *  $sanatize = array('alias');
 *
 *  $validator = new FormValidator($validations, $required, $sanatize);
 *                  
 *  if($validator->validate($_POST))
 *  {
 *      $_POST = $validator->sanatize($_POST);
 *      // now do your saving, $_POST has been sanatized.
 *      die($validator->getScript()."<script type='text/javascript'>alert('saved changes');</script>");
 *  }
 *  else
 *  {
 *      die($validator->getScript());
 *  }   
 *  
 * To validate just one element:
 * $validated = new FormValidator()->validate('blah@bla.', 'email');
 * 
 * To sanatize just one element:
 * $sanatized = new FormValidator()->sanatize('<b>blah</b>', 'string');
 * 
 * @package pork
 * @author SchizoDuckie
 * @copyright SchizoDuckie 2008
 * @version 1.0
 * @access public
 */
class FormValidator
{
    public static $regexes = Array(
            'date' => "^[0-9]{1,2}[-/][0-9]{1,2}[-/][0-9]{4}\$",
            'amount' => "^[-]?[0-9]+\$",
            'number' => "^[-]?[0-9,]+\$",
            'alfanum' => "^[0-9a-zA-Z ,.-_\\s\?\!]+\$",
            'not_empty' => "[a-z0-9A-Z]+",
            'words' => "^[A-Za-z]+[A-Za-z \\s]*\$",
            'phone' => "^[0-9]{10,11}\$",
            'zipcode' => "^[1-9][0-9]{3}[a-zA-Z]{2}\$",
            'plate' => "^([0-9a-zA-Z]{2}[-]){2}[0-9a-zA-Z]{2}\$",
            'price' => "^[0-9.,]*(([.,][-])|([.,][0-9]{2}))?\$",
            '2digitopt' => "^\d+(\,\d{2})?\$",
            '2digitforce' => "^\d+\,\d\d\$",
            'anything' => "^[\d\D]{1,}\$"
    );
    private $validations, $sanatations, $mandatories, $errors, $corrects, $fields;


    public function __construct($validations=array(), $mandatories = array(), $sanatations = array())
    {
        $this->validations = $validations;
        $this->sanatations = $sanatations;
        $this->mandatories = $mandatories;
        $this->errors = array();
        $this->corrects = array();
    }

    /**
     * Validates an array of items (if needed) and returns true or false
     *
     */
    public function validate($items)
    {
        $this->fields = $items;
        $havefailures = false;
        foreach($items as $key=>$val)
        {
            if((strlen($val) == 0 || array_search($key, $this->validations) === false) && array_search($key, $this->mandatories) === false) 
            {
                $this->corrects[] = $key;
                continue;
            }
            $result = self::validateItem($val, $this->validations[$key]);
            if($result === false) {
                $havefailures = true;
                $this->addError($key, $this->validations[$key]);
            }
            else
            {
                $this->corrects[] = $key;
            }
        }

        return(!$havefailures);
    }

    /**
     *
     *  Adds unvalidated class to thos elements that are not validated. Removes them from classes that are.
     */
    public function getScript() {
        if(!empty($this->errors))
        {
            $errors = array();
            foreach($this->errors as $key=>$val) { $errors[] = "'INPUT[name={$key}]'"; }

            $output = '$$('.implode(',', $errors).').addClass("unvalidated");'; 
            $output .= "new FormValidator().showMessage();";
        }
        if(!empty($this->corrects))
        {
            $corrects = array();
            foreach($this->corrects as $key) { $corrects[] = "'INPUT[name={$key}]'"; }
            $output .= '$$('.implode(',', $corrects).').removeClass("unvalidated");';   
        }
        $output = "<script type='text/javascript'>{$output} </script>";
        return($output);
    }


    /**
     *
     * Sanatizes an array of items according to the $this->sanatations
     * sanatations will be standard of type string, but can also be specified.
     * For ease of use, this syntax is accepted:
     * $sanatations = array('fieldname', 'otherfieldname'=>'float');
     */
    public function sanatize($items)
    {
        foreach($items as $key=>$val)
        {
            if(array_search($key, $this->sanatations) === false && !array_key_exists($key, $this->sanatations)) continue;
            $items[$key] = self::sanatizeItem($val, $this->validations[$key]);
        }
        return($items);
    }


    /**
     *
     * Adds an error to the errors array.
     */ 
    private function addError($field, $type='string')
    {
        $this->errors[$field] = $type;
    }

    /**
     *
     * Sanatize a single var according to $type.
     * Allows for static calling to allow simple sanatization
     */
    public static function sanatizeItem($var, $type)
    {
        $flags = NULL;
        switch($type)
        {
            case 'url':
                $filter = FILTER_SANITIZE_URL;
            break;
            case 'int':
                $filter = FILTER_SANITIZE_NUMBER_INT;
            break;
            case 'float':
                $filter = FILTER_SANITIZE_NUMBER_FLOAT;
                $flags = FILTER_FLAG_ALLOW_FRACTION | FILTER_FLAG_ALLOW_THOUSAND;
            break;
            case 'email':
                $var = substr($var, 0, 254);
                $filter = FILTER_SANITIZE_EMAIL;
            break;
            case 'string':
            default:
                $filter = FILTER_SANITIZE_STRING;
                $flags = FILTER_FLAG_NO_ENCODE_QUOTES;
            break;

        }
        $output = filter_var($var, $filter, $flags);        
        return($output);
    }

    /** 
     *
     * Validates a single var according to $type.
     * Allows for static calling to allow simple validation.
     *
     */
    public static function validateItem($var, $type)
    {
        if(array_key_exists($type, self::$regexes))
        {
            $returnval =  filter_var($var, FILTER_VALIDATE_REGEXP, array("options"=> array("regexp"=>'!'.self::$regexes[$type].'!i'))) !== false;
            return($returnval);
        }
        $filter = false;
        switch($type)
        {
            case 'email':
                $var = substr($var, 0, 254);
                $filter = FILTER_VALIDATE_EMAIL;    
            break;
            case 'int':
                $filter = FILTER_VALIDATE_INT;
            break;
            case 'boolean':
                $filter = FILTER_VALIDATE_BOOLEAN;
            break;
            case 'ip':
                $filter = FILTER_VALIDATE_IP;
            break;
            case 'url':
                $filter = FILTER_VALIDATE_URL;
            break;
        }
        return ($filter === false) ? false : filter_var($var, $filter) !== false ? true : false;
    }       



}

Naturalmente, tieni presente che devi fare in modo che anche la tua query sql scappi, a seconda del tipo di db che stai usando (mysql_real_escape_string () è inutile per un server sql, ad esempio). Probabilmente vuoi gestirlo automaticamente al tuo livello di applicazione appropriato come un ORM. Inoltre, come menzionato sopra: per l'output in html usa le altre funzioni php dedicate come htmlspecialchars;)

Per consentire davvero l'input HTML con simili classi e / o tag simili dipende da uno dei pacchetti di validazione xss dedicati. NON SCRIVERE I PROPRI RIFERIMENTI A PARSE HTML!

No, non esiste.

Prima di tutto, l'iniezione di SQL è un problema di filtro di input e XSS è un output che sfugge a uno - quindi non dovresti nemmeno eseguire queste due operazioni contemporaneamente nel ciclo di vita del codice.

Regole pratiche di base

  • Per la query SQL, associare i parametri (come con PDO) o utilizzare una funzione di escape nativa del driver per le variabili della query (come mysql_real_escape_string())
  • Utilizza strip_tags() per filtrare HTML indesiderato
  • Esci da tutti gli altri output con htmlspecialchars() e fai attenzione ai parametri 2 ° e 3 ° qui.

Per risolvere il problema XSS, dai un'occhiata a Purificatore HTML . È abbastanza configurabile e ha un discreto track record.

Per quanto riguarda gli attacchi SQL injection, assicurati di controllare l'input dell'utente, quindi eseguilo attraverso mysql_real_escape_string (). La funzione non annullerà tutti gli attacchi di iniezione, quindi è importante controllare i dati prima di scaricarli nella stringa di query.

Una soluzione migliore è usare le istruzioni preparate. La libreria PDO e l'estensione mysqli supportano questi.

PHP 5.2 ha introdotto la funzione filter_var .

Supporta moltissimi filtri SANITIZE, VALIDATE.

http://php.net/manual/en/function.filter- var.php

Un trucco che può aiutare nella circostanza specifica in cui hai una pagina come /mypage?id=53 e usi l'id in una clausola WHERE è quello di assicurarti che id sia sicuramente un numero intero, in questo modo: 

if (isset($_GET['id'])) {
  $id = $_GET['id'];
  settype($id, 'integer');
  $result = mysql_query("SELECT * FROM mytable WHERE id = '$id'");
  # now use the result
}

Ma ovviamente questo elimina solo un attacco specifico, quindi leggi tutte le altre risposte. (E sì, so che il codice sopra non è eccezionale, ma mostra la difesa specifica.)

  

Metodi per la disinfezione dell'input dell'utente con PHP:

  • Usa le versioni moderne di MySQL e PHP.

  • Imposta esplicitamente il set di caratteri: 

    • $mysqli->set_charset("utf8");
      manual 
    • $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);
      manual 
    • $pdo->exec("set names utf8");
      manual 
    • $pdo = new PDO(
"mysql:host=$host;dbname=$db", $user, $pass, 
array(
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"
)
);
      manual 
    • mysql_set_charset('utf8')
      [deprecato in PHP 5.5.0, rimosso in PHP 7.0.0].

  • Usa set di caratteri sicuri:

    • Seleziona utf8, latin1, ascii .., non usare caratteri vulnerabili big5, cp932, gb2312, gbk, sjis.

  • Usa la funzione spazializzata:

    • Dichiarazioni preparate da MySQLi: 
      $stmt = $mysqli->prepare('SELECT * FROM test WHERE name = ? LIMIT 1'); 
      $param = "' OR 1=1 /*";
      $stmt->bind_param('s', $param);
      $stmt->execute();

    • PDO :: quote () - posiziona le virgolette intorno al stringa di input (se richiesto) e sfugge ai caratteri speciali all'interno della stringa di input, utilizzando uno stile di quotazione appropriato per il driver sottostante: 

      $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);explicit set the character set
      $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);disable emulating prepared statements to prevent  fallback to emulating statements that MySQL can't prepare natively (to prevent injection)
      $var  = $pdo->quote("' OR 1=1 /*");not only escapes the literal, but also quotes it (in single-quote ' characters)
$stmt = $pdo->query("SELECT * FROM test WHERE name = $var LIMIT 1");

    • Dichiarazioni preparate DOP : le dichiarazioni preparate da MySQLi supportano più database driver e parametri nominati: 

      $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);explicit set the character set
      $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);disable emulating prepared statements to prevent  fallback to emulating statements that MySQL can't prepare natively (to prevent injection)
$stmt = $pdo->prepare('SELECT * FROM test WHERE name = ? LIMIT 1');
$stmt->execute(["' OR 1=1 /*"]);

    • mysql_real_escape_string [deprecato in PHP 5.5.0, rimosso in PHP 7.0.0].
    • mysqli_real_escape_string Elimina caratteri speciali in una stringa per l'uso in un'istruzione SQL, tenendo conto del set di caratteri corrente della connessione. Ma si consiglia di utilizzare istruzioni preparate perché non sono semplicemente stringhe di escape, un'istruzione fornisce un piano di esecuzione delle query completo, inclusi quali tabelle e indici utilizzare, è un modo ottimizzato.
    • Usa virgolette singole ('') attorno alle tue variabili all'interno della tua query.

  • Verifica che la variabile contenga ciò che ti aspetti:

    • Se ti aspetti un numero intero, usa: 
      ctype_digit — Check for numeric character(s);
      $value = (int) $value;
      $value = intval($value);
      $var = filter_var('0755', FILTER_VALIDATE_INT, $options);
    • Per le stringhe usare: 
      is_string() — Find whether the type of a variable is string

      Usa Funzione filtro filter_var () & # 8212 ; filtra una variabile con un filtro specificato: 
      $email = filter_var($email, FILTER_SANITIZE_EMAIL);
      $newstr = filter_var($str, FILTER_SANITIZE_STRING);
      più filtri predefiniti
    • filter_input () & # 8212; Ottiene una variabile esterna specifica per nome e facoltativamente la filtra: 
      $search_html = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);
    • preg_match () & # 8212; Esegui una corrispondenza di espressioni regolari;
    • Scrivi la tua funzione di validazione.

Quello che stai descrivendo qui è due problemi separati:

  1. Disinfezione / filtro dei dati di input dell'utente.
  2. Uscita di escape.

1) L'input dell'utente dovrebbe sempre essere considerato errato.

L'uso di istruzioni preparate, o / e il filtro con mysql_real_escape_string è sicuramente un must. PHP ha anche filter_input integrato in cui è un buon punto di partenza.

2) Questo è un argomento di grandi dimensioni e dipende dal contesto dei dati in uscita. Per HTML ci sono soluzioni come htmlpurifier là fuori. come regola generale, evita sempre qualsiasi cosa tu abbia prodotto.

Entrambi i problemi sono troppo grandi per essere inseriti in un singolo post, ma ci sono molti post che vanno più in dettaglio:

Metodi di output PHP

Output PHP più sicuro

Se stai usando PostgreSQL, l'input da PHP può essere evitato con pg_escape_string () 

 $username = pg_escape_string($_POST['username']);

Dalla documentazione ( http://php.net/manual /es/function.pg-escape-string.php ):

  

pg_escape_string () esegue l'escape di una stringa per l'interrogazione del database. Restituisce una stringa con escape nel formato PostgreSQL senza virgolette.

Il modo più semplice per evitare errori nella sanificazione dell'input e nella fuga di dati consiste nell'utilizzare il framework PHP come Symfony , Nette ecc. o parte di quel framework (motore di template, layer di database, ORM).

Motore di creazione di modelli come Twig o Latte ha un output che sta scappando di default - non devi risolvere manualmente se hai evitato correttamente l'output in base al contesto (parte HTML o Javascript della pagina Web).

Framework sta automaticamente disinfettando l'input e non dovresti usare direttamente le variabili $ _POST, $ _GET o $ _SESSION, ma attraverso meccanismi come routing, gestione delle sessioni ecc.

E per il livello di database (modello) ci sono framework ORM come Doctrine o wrapper attorno a PDO come Nette Database.

Puoi leggere di più qui - Che cos'è un framework software?

Non esiste una funzione catchall, perché ci sono più preoccupazioni da affrontare.

  1. Iniezione SQL - Oggi, generalmente, ogni progetto PHP dovrebbe utilizzare dichiarazioni preparate tramite PHP Data Objects (PDO) come best practice, prevenendo un errore da una citazione vagante e una soluzione completa contro l'iniezione . È anche il più flessibile & amp; modo sicuro per accedere al tuo database.

    Dai un'occhiata a (L'unico vero) tutorial PDO per praticamente tutto ciò che bisogno di sapere sulla DOP. (Un grazie sincero al miglior collaboratore SO, @YourCommonSense, per questa grande risorsa sull'argomento.)

  2. XSS - Disinfetta i dati sulla strada in ...

    • Purificatore HTML è in circolazione da molto tempo ed è ancora attivamente aggiornato. Puoi usarlo per disinfettare input dannosi, pur consentendo un generoso & amp; whitelist configurabile di tag. Funziona alla grande con molti editor WYSIWYG, ma potrebbe essere pesante per alcuni casi d'uso.

    • In altri casi, in cui non vogliamo affatto accettare HTML / Javascript, ho trovato utile questa semplice funzione (e ha superato più audit su XSS):

      / * Impedisci input XSS * / funzione sanitizeXSS () {     $ _GET = filter_input_array (INPUT_GET, FILTER_SANITIZE_STRING);     $ _POST = filter_input_array (INPUT_POST, FILTER_SANITIZE_STRING);     $ _REQUEST = (matrice) $ _ POST + (matrice) $ _ OTTIENI + (matrice) $ _ RICHIESTA; }

  3. XSS - Disinfezione dei dati in uscita ... a meno che non si garantisca che i dati siano stati adeguatamente disinfettati prima di aggiungerli al database, è necessario disinfettarli prima di visualizzarli per il tuo utente, possiamo sfruttare queste utili funzioni PHP:

    • Quando si chiama echo o print per visualizzare i valori forniti dall'utente, utilizzare htmlspecialchars a meno che i dati non siano stati adeguatamente sterilizzati sicuri e sia consentito visualizzare HTML.
    • json_encode è sicuro modo per fornire valori forniti dall'utente da PHP a Javascript

  4. Chiamate comandi shell esterni usando exec () o system () o backtick operatore? In tal caso, oltre a SQL Injection & amp; XSS potresti avere un'ulteriore preoccupazione da affrontare, utenti che eseguono comandi dannosi sul tuo server . Devi usare escapeshellcmd se vuoi piace sfuggire all'intero comando OPPURE escapeshellarg a sfuggire ai singoli argomenti.

Non fidarti mai dei dati dell'utente. 

function clean_input($data) {
  $data = trim($data);
  $data = stripslashes($data);
  $data = htmlspecialchars($data);
  return $data;
}

La funzione trim () rimuove gli spazi bianchi e altri caratteri predefiniti da entrambi i lati di una stringa.

La funzione stripeslashes () rimuove le barre rovesciate

La funzione htmlspecialchars () converte alcuni caratteri predefiniti in entità HTML.

I caratteri predefiniti sono: 

& (ampersand) becomes &amp;
" (double quote) becomes &quot;
' (single quote) becomes &#039;
< (less than) becomes &lt;
> (greater than) becomes &gt;

Volevo solo aggiungerlo sull'argomento dell'escaping dell'output, se usi php DOMDocument per creare il tuo output html, questo automaticamente scapperà nel giusto contesto. Un attributo (valore = " ") e il testo interno di un < span > non sono uguali. Per essere sicuri contro XSS leggi questo: Foglio informativo sulla prevenzione XSS OWASP

Non disinfettare mai l'input.

Disinfetta sempre l'output.

Le trasformazioni applicate ai dati per renderlo sicuro per l'inclusione in un'istruzione SQL sono completamente diverse da quelle che si applicano per l'inclusione in HTML sono completamente diverse da quelle che si applicano per l'inclusione in Javascript sono completamente diverse da quelle che si applicano per l'inclusione in LDIF sono completamente diversi da quelli applicati all'inclusione nei CSS sono completamente diversi da quelli applicati all'inclusione in un'e-mail ....

Certamente validate input - decidere se accettarlo per ulteriori elaborazioni o dire all'utente che è inaccettabile. Ma non applicare alcuna modifica alla rappresentazione dei dati fino a quando non sta per lasciare la terra PHP.

Molto tempo fa qualcuno ha cercato di inventare un meccanismo a misura unica per sfuggire ai dati e abbiamo finito con " magic_quotes " che non sfuggiva correttamente ai dati per tutte le destinazioni di output e provocava un'installazione diversa che richiedeva il funzionamento di un codice diverso.

Esiste l'estensione del filtro ( howto-link , manual ), che funziona abbastanza bene con tutte le variabili GPC. Non è una cosa magica, dovrai comunque usarla.

Riesco a vedere il filtro php disinfettare speciali caratteri speciali che tornano utili.

mi piace: 

    $a=fliter_var(
 Riesco a vedere il filtro php disinfettare speciali caratteri speciali che tornano utili. 



 mi piace: 



    void php_filter_special_chars(PHP_INPUT_FILTER_PARAM_DECL)
{
unsigned char enc[256] = {0};

php_filter_strip(value, flags);

/* encodes ' " < > & \0 to numerical entities */
enc['\''] = enc['"'] = enc['<'] = enc['>'] = enc['&'] = enc[0] = 1;

/* if strip low is not set, then we encode them as &#xx; */
memset(enc, 1, 32);

if (flags & FILTER_FLAG_ENCODE_HIGH) {
    memset(enc + 127, 1, sizeof(enc) - 127);
}

php_filter_encode_html(value, enc);
}




 Tuttavia, per stock, penso che potrebbe essere migliore, perché guardando il codice c, filtra solo il " '\ < & Gt; & Amp; e \ 0 così posso vedere che questo è un buon modo di disinfettare. Tuttavia, cambiando il codice sorgente per includere questi altri caratteri come / {} []. ; `rafforzerebbe questa funzione sulla riga encode (enc ['']): 


<*>POST['a'],FILTER_SANITIZE_SPECIAL_CHARS);

Tuttavia, per stock, penso che potrebbe essere migliore, perché guardando il codice c, filtra solo il " '\ < & Gt; & Amp; e \ 0 così posso vedere che questo è un buon modo di disinfettare. Tuttavia, cambiando il codice sorgente per includere questi altri caratteri come / {} []. ; `rafforzerebbe questa funzione sulla riga encode (enc ['']):

<*>

Il miglior metodo BASIC per sanificare l'input dell'utente con PHP: 


    function sanitizeString($var)
    {
        $var = stripslashes($var);
        $var = strip_tags($var);
        $var = htmlentities($var);
        return $var;
    }

    function sanitizeMySQL($connection, $var)
    {
        $var = $connection->real_escape_string($var);
        $var = sanitizeString($var);
        return $var;
    }
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top