Comment puis-je nettoyer l'entrée utilisateur avec PHP?

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

Question

Existe-t-il une fonction catchall quelque part qui fonctionne bien pour supprimer les entrées utilisateur pour les attaques par injection SQL et XSS, tout en autorisant certains types de balises HTML?

Était-ce utile?

La solution

C'est une idée fausse commune que les entrées d'utilisateur peuvent être filtrées. PHP a même une & "; Fonctionnalité &" (Maintenant obsolète), appelée "citations magiques", qui s'appuie sur cette idée. C'est n'importe quoi. Oubliez le filtrage (ou le nettoyage, ou ce que les gens appellent cela).

Ce que vous devez faire, pour éviter les problèmes, est très simple: chaque fois que vous intégrez une chaîne dans un code étranger, vous devez l’échapper, conformément aux règles de cette langue. Par exemple, si vous incorporez une chaîne dans un SQL ciblant MySql, vous devez pour cela échapper la chaîne avec la fonction de MySql (mysqli_real_escape_string). (Ou, dans le cas de bases de données, utiliser des instructions préparées est une meilleure approche, lorsque cela est possible)

Un autre exemple est HTML: si vous incorporez des chaînes dans un balisage HTML, vous devez les échapper avec <= > . Cela signifie que chaque htmlspecialchars ou echo déclaration doit utiliser print.

Un troisième exemple pourrait être les commandes shell: Si vous allez incorporer des chaînes (telles que des arguments) à des commandes externes, et appelez-les avec exec , vous devez utiliser escapeshellcmd et escapeshellarg .

Et ainsi de suite ...

Le cas uniquement dans lequel vous devez filtrer activement les données est le cas si vous acceptez une entrée préformatée. Par exemple. si vous laissez vos utilisateurs publier du balisage HTML, vous prévoyez de l'afficher sur le site. Cependant, vous devriez éviter de le faire à tout prix, car peu importe la qualité de votre filtrage, ce sera toujours un trou de sécurité potentiel.

Autres conseils

N'essayez pas d'empêcher l'injection SQL en nettoyant les données d'entrée.

Au lieu de cela, n'autorisez pas l'utilisation de données dans la création de votre code SQL . Utilisez les instructions préparées (c'est-à-dire à l'aide de paramètres dans une requête de modèle) qui utilise des variables liées. C’est le seul moyen d’être garanti contre l’injection SQL.

Veuillez consulter mon site Web http://bobby-tables.com/ pour plus d'informations sur la prévention de l'injection SQL.

Non. Vous ne pouvez pas filtrer les données de manière générique sans définir le contexte. Parfois, vous voudrez prendre une requête SQL en entrée et parfois, vous voudrez prendre HTML en entrée.

Vous devez filtrer les entrées sur une liste blanche - assurez-vous que les données correspondent aux spécifications de ce que vous attendez. Ensuite, vous devez l’échapper avant de l’utiliser, en fonction du contexte dans lequel vous l’utilisez.

Le processus d’échappement de données pour SQL - pour empêcher l’injection SQL - est très différent du processus d’échappement de données pour (X) HTML pour empêcher XSS.

PHP dispose maintenant des nouvelles fonctions filter_input, qui vous libèrent par exemple de la recherche de la "regex de messagerie ultime" maintenant qu'il existe un type FILTER_VALIDATE_EMAIL intégré

Ma propre classe de filtre (utilisant javascript pour mettre en évidence les champs défectueux) peut être lancée par une requête ajax ou par une publication normale. (voir l'exemple ci-dessous)      

/**
 *  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;
    }       



}

Bien sûr, gardez à l’esprit que vous devez également échapper votre requête SQL en fonction du type de base de données que vous utilisez (mysql_real_escape_string () est inutile pour un serveur SQL par exemple). Vous voudrez probablement gérer cela automatiquement au niveau de votre couche applicative appropriée, comme un ORM. En outre, comme mentionné ci-dessus: pour la sortie au format HTML, utilisez les autres fonctions dédiées à PHP telles que htmlspecialchars;)

Pour réellement permettre l’entrée HTML avec des classes et / ou des balises dépourvues comme celles-ci, cela dépend de l’un des packages de validation xss dédiés. N'ECRIVEZ PAS VOS PROGRES REGRES A PARSEER HTML!

Non, il n'y en a pas.

Tout d’abord, l’injection SQL est un problème de filtrage des entrées et XSS est une sortie qui en échappe. Par conséquent, vous ne pourriez même pas exécuter ces deux opérations en même temps dans le cycle de vie du code.

Règles de base

  • Pour une requête SQL, liez des paramètres (comme avec PDO) ou utilisez une fonction d'échappement native du pilote pour les variables de requête (telles que mysql_real_escape_string())
  • Utilisez strip_tags() pour filtrer le code HTML indésirable
  • Échappez à toutes les autres sorties avec htmlspecialchars() et tenez compte des deuxième et troisième paramètres ici.

Pour résoudre le problème XSS, consultez le purificateur HTML . Il est assez configurable et a un bon bilan.

En ce qui concerne les attaques par injection SQL, vérifiez bien la saisie de l'utilisateur, puis exécutez-la via mysql_real_escape_string (). Toutefois, la fonction ne supprimera pas toutes les attaques par injection. Il est donc important de vérifier les données avant de les transférer dans votre chaîne de requête.

Une meilleure solution consiste à utiliser des instructions préparées. La bibliothèque PDO et l'extension mysqli les prennent en charge.

PHP 5.2 a introduit la fonction filter_var .

Il prend en charge de nombreux filtres SANITIZE, VALIDATE.

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

Une astuce qui peut aider dans les cas spécifiques où vous avez une page comme /mypage?id=53 et que vous utilisez l'identifiant dans une clause WHERE est de s'assurer que cet identifiant est bien un entier, comme ceci: 

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

Mais bien sûr, cela ne supprime qu'une attaque en particulier, alors lisez toutes les autres réponses. (Et oui, je sais que le code ci-dessus n’est pas génial, mais il montre la défense spécifique.)

  

Méthodes de nettoyage des entrées utilisateur avec PHP:

  • Utilisez les versions modernes de MySQL et PHP.

  • Définir explicitement le jeu de caractères: 

    • $mysqli->set_charset("utf8");
      manuel / li> 
    • $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);
      manuel 
    • $pdo->exec("set names utf8");
      manuel 
    • $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"
)
);
      manuel . / li> 
    • mysql_set_charset('utf8')
      [obsolète en PHP 5.5.0, supprimé en PHP 7.0.0].

  • Utiliser des jeux de caractères sécurisés:

    • Sélectionnez utf8, latin1, ascii .., n'utilisez pas de jeux de caractères vulnérables big5, cp932, gb2312, gbk, sjis.

  • Utiliser la fonction spatialisée:

    • Instructions préparées par MySQLi: 
      $stmt = $mysqli->prepare('SELECT * FROM test WHERE name = ? LIMIT 1'); 
      $param = "' OR 1=1 /*";
      $stmt->bind_param('s', $param);
      $stmt->execute();

    • PDO :: quote () - place des guillemets autour du chaîne d'entrée (si nécessaire) et échappe aux caractères spéciaux de la chaîne d'entrée, en utilisant un style de citation adapté au pilote sous-jacent: 

      $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");

    • Instructions préparées PDO : Les instructions préparées par MySQLi prennent en charge davantage de bases de données pilotes et paramètres nommés: 

      $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 [obsolète en PHP 5.5.0, supprimé en PHP 7.0.0].
    • mysqli_real_escape_string Echappe aux caractères spéciaux d'une chaîne pour les utiliser une instruction SQL tenant compte du jeu de caractères actuel de la connexion. Mais il est recommandé d'utiliser les instructions préparées, car il ne s'agit pas simplement de chaînes échappées. Une instruction fournit un plan d'exécution complet de la requête, y compris les tables et les index qu'elle utiliserait, il s'agit d'une méthode optimisée.
    • Utilisez des guillemets simples ('') autour de vos variables dans votre requête.

  • Vérifiez que la variable contient ce à quoi vous vous attendez:

    • Si vous attendez un entier, utilisez: 
      ctype_digit — Check for numeric character(s);
      $value = (int) $value;
      $value = intval($value);
      $var = filter_var('0755', FILTER_VALIDATE_INT, $options);
    • Pour les chaînes, utilisez: 
      is_string() — Find whether the type of a variable is string

      Utilisez la fonction de filtrage filter_var () & # 8212 ; filtre une variable avec un filtre spécifié: 
      $email = filter_var($email, FILTER_SANITIZE_EMAIL);
      $newstr = filter_var($str, FILTER_SANITIZE_STRING);
      filtres plus prédéfinis
    • filter_input () & # 8212; Obtient une variable externe spécifique par son nom et le filtre éventuellement: 
      $search_html = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);
    • preg_match () & # 8212; Effectuer une correspondance d'expression régulière;
    • Écrivez votre propre fonction de validation.

Vous décrivez ici deux problèmes distincts:

  1. Désinfection / filtrage des données saisies par l'utilisateur.
  2. Échappement en sortie.

1) La saisie de l'utilisateur doit toujours être considérée comme incorrecte.

Utiliser des instructions préparées, et / ou filtrer avec mysql_real_escape_string est vraiment indispensable. PHP possède également filter_input, ce qui en fait un bon point de départ.

2) Il s'agit d'un sujet volumineux, qui dépend du contexte des données en sortie. Pour HTML, il existe des solutions telles que htmlpurifier. en règle générale, échappez toujours à tout ce que vous publiez.

Les deux problèmes sont beaucoup trop volumineux pour figurer dans un seul article, mais de nombreux articles sont plus détaillés:

Méthodes Sortie PHP

Sortie PHP plus sûre

Si vous utilisez PostgreSQL, vous pouvez échapper l'entrée de PHP avec pg_escape_string () 

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

Extrait de la documentation ( http://php.net/manual /es/function.pg-escape-string.php ):

  

pg_escape_string () échappe à une chaîne pour interroger la base de données. Il renvoie une chaîne d'échappement au format PostgreSQL sans guillemets.

Le moyen le plus simple d'éviter les erreurs de nettoyage des entrées et des données d'échappement consiste à utiliser un framework PHP tel que Symfony , Nette , etc., ou une partie de ce cadre (moteur de modélisation, couche de base de données, ORM).

Le moteur de création de modèles tel que Twig ou Latte a une sortie qui s'échappe par défaut - vous n'avez pas à résoudre le problème. manuellement si vous avez correctement échappé votre sortie en fonction du contexte (partie HTML ou Javascript de la page Web).

La structure désinfecte automatiquement les entrées et vous ne devez pas utiliser directement les variables $ _POST, $ _GET ou $ _SESSION, mais par le biais d'un mécanisme comme le routage, la gestion de session, etc.

Et pour la couche base de données (modèle), il existe des cadres ORM comme Doctrine ou des wrappers autour de PDO comme Nette Database.

Vous pouvez en savoir plus à ce sujet ici - Qu'est-ce qu'un framework logiciel?

Il n'y a pas de fonction fourre-tout, car les problèmes à résoudre sont multiples.

  1. Injection SQL - De nos jours, tous les projets PHP devraient utiliser instructions préparées via PHP Data Objects (PDO) , qui constituent une pratique recommandée, en empêchant une erreur provenant d'une citation parasite ainsi qu'une solution complète contre l'injection . . C'est aussi le plus flexible & amp; moyen sécurisé d'accéder à votre base de données.

    Découvrez le (Le seul bon tutoriel sur les PDO ) pour à peu près tout ce que vous besoin de savoir sur le PDO. (Merci sincèrement à @YourCommonSense, principal contributeur à SO, pour cette excellente ressource sur le sujet.)

  2. XSS - Désinfectez les données en chemin ...

    • Purificateur HTML existe depuis longtemps et est toujours mis à jour activement. Vous pouvez l'utiliser pour supprimer les entrées malveillantes, tout en permettant une exécution généreuse & amp; liste blanche configurable de tags. Fonctionne très bien avec de nombreux éditeurs WYSIWYG, mais cela peut être lourd pour certains cas d'utilisation.

    • Dans d'autres cas, où nous ne voulons pas du tout accepter HTML / Javascript, j'ai trouvé cette fonction simple utile (et passé plusieurs audits contre XSS):

      / * Empêcher l'entrée XSS * / fonction sanitizeXSS () {     $ _GET = filter_input_array (INPUT_GET, FILTER_SANITIZE_STRING);     $ _POST = filter_input_array (INPUT_POST, FILTER_SANITIZE_STRING);     $ _REQUEST = (tableau) $ _ POST + (tableau) $ _ GET + (tableau) $ _ REQUEST; }

  3. XSS - Désinstallez les données avant de les quitter ... , à moins que vous ne garantissiez que les données ont été correctement filtrées avant de les ajouter à votre base de données, vous devrez les désinfecter avant de les afficher. Pour votre utilisateur, nous pouvons tirer parti de ces fonctions PHP utiles:

    • Lorsque vous appelez echo ou print pour afficher les valeurs fournies par l'utilisateur, utilisez htmlspecialchars à moins que les données n'aient été correctement filtrées, qu'elles soient autorisées à afficher du code HTML.
    • json_encode est un coffre-fort moyen de fournir des valeurs fournies par l'utilisateur de PHP à Javascript

  4. Appelez-vous des commandes de shell externes à l'aide de exec () ou system () , ou aux backtick operator? Si c'est le cas, en plus de SQL Injection & amp; XSS, vous pourriez avoir un problème supplémentaire à résoudre, les utilisateurs exécutant des commandes malveillantes sur votre serveur . Vous devez utiliser escapeshellcmd si vous le souhaitez. tiens à échapper à la commande entière OU escapeshellarg à échapper à des arguments individuels.

Ne faites jamais confiance aux données utilisateur. 

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

La fonction trim () supprime les espaces et autres caractères prédéfinis des deux côtés d'une chaîne.

La fonction stripslashes () supprime les barres obliques inverses

La fonction htmlspecialchars () convertit certains caractères prédéfinis en entités HTML.

Les caractères prédéfinis sont: 

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

Je voulais juste ajouter cela au sujet de l'échappement de sortie, si vous utilisez php DOMDocument pour rendre votre sortie html, elle s'échappera automatiquement dans le bon contexte. Un attribut (value = ") et le texte intérieur d'un < span > ne sont pas égaux. Pour être sûr contre XSS, lisez ceci: Aide-mémoire de prévention OWASP XSS

Vous ne désinfectez jamais l'entrée.

Vous nettoyez toujours la sortie.

Les transformations que vous appliquez aux données pour les rendre sûres en vue d'une inclusion dans une instruction SQL sont complètement différentes de celles que vous demandez pour l'inclusion au format HTML sont complètement différentes de celles que vous demandez pour l'inclusion en Javascript et sont complètement différentes de celles que vous appliquez pour l'inclusion dans LDIF sont complètement différentes de celles que vous appliquez à l'inclusion dans CSS sont complètement différentes de celles que vous appliquez à l'inclusion dans un e-mail ....

Bien sûr, valider la saisie - décidez si vous devez l'accepter pour un traitement ultérieur ou dites à l'utilisateur que c'est inacceptable. Mais n’appliquez aucun changement à la représentation des données avant que celles-ci ne soient sur le point de quitter PHP.

Il y a longtemps, quelqu'un a essayé d'inventer un mécanisme unique pour échapper des données. Nous nous sommes retrouvés avec un " magic_quotes " qui n'a pas échappé correctement aux données de toutes les cibles de sortie et a entraîné une installation différente nécessitant un code différent pour fonctionner.

Il existe l'extension de filtre ( howto-link , manual ), qui fonctionne plutôt bien avec toutes les variables GPC. Ce n’est pas une chose magique à faire mais vous devrez quand même l’utiliser.

Je peux voir le filtre php désinfecter des caractères spéciaux spéciaux très utiles.

comme: 

    $a=fliter_var(
 Je peux voir le filtre php désinfecter des caractères spéciaux spéciaux très utiles. 



 comme: 



    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);
}




 Cependant, en stock, je pense que cela pourrait être mieux, car en regardant le code c, cela ne fait que filtrer le " '\ < > & amp; et \ 0 je peux donc voir que c’est un bon moyen de désinfection. Cependant, changer le code source pour inclure ces autres caractères comme / {} []. ; `renforcerait cette fonction sur la ligne encode (enc ['']]): 


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

Cependant, en stock, je pense que cela pourrait être mieux, car en regardant le code c, cela ne fait que filtrer le " '\ < > & amp; et \ 0 je peux donc voir que c’est un bon moyen de désinfection. Cependant, changer le code source pour inclure ces autres caractères comme / {} []. ; `renforcerait cette fonction sur la ligne encode (enc ['']]):

<*>

La meilleure méthode BASIC pour nettoyer les entrées utilisateur avec 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;
    }
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top