web-dev-qa-db-fra.com

Quelle est la meilleure méthode pour supprimer les entrées utilisateur avec PHP?

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

phpsecurityxsssql-injectionuser-input
1018
Brent

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 magic-quotes, qui s'appuie sur cette idée. C'est n'importe quoi. Oubliez le filtrage (ou le nettoyage, ou ce que les gens appellent ça).

Pour éviter les problèmes, ce que vous devez faire 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 une cible SQL ciblant MySql, vous devez pour cela échapper la chaîne avec la fonction MySql (mysqli_real_escape_string). (Ou, dans le cas de bases de données, utiliser des déclarations préparées est une meilleure approche, si possible)

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

Un troisième exemple pourrait être les commandes Shell: si vous souhaitez incorporer des chaînes (telles que des arguments) à des commandes externes et les appeler avec exec , vous devez utiliser escapeshellcmd et escapeshellarg .

Et ainsi de suite ...

Le cas uniquement où vous devez activement filtrer les données est le cas si vous acceptez une entrée préformatée. Par exemple. si vous laissez vos utilisateurs publier des balises HTML, vous prévoyez de les afficher sur le site. Cependant, vous devriez éviter cela à tout prix, car peu importe la qualité de votre filtrage, ce sera toujours une faille de sécurité potentielle.

1108
troelskn

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

N'autorise pas l'utilisation de données dans la création de votre code SQL. Utilisez les instructions préparées (c’est-à-dire en utilisant des 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.

191
Andy Lester

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

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 y é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.

73
Daniel Papasian

PHP a maintenant les nouvelles fonctions Nice filter_input, qui vous libèrent par exemple de la recherche de la "regex de courrier électronique ultime" maintenant qu'il existe un type intégré FILTER_VALIDATE_EMAIL

Ma propre classe de filtre (utilisant javascript pour mettre en évidence les champs défectueux) peut être lancée soit par une requête ajax, soit 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 aussi é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 comme htmlspecialchars;)

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

46
SchizoDuckie

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 pouvez même pas exécuter ces deux opérations simultanément 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 (telle que mysql_real_escape_string())
  • Utilisez strip_tags() pour filtrer le HTML indésirable
  • Echappez à toutes les autres sorties avec htmlspecialchars() et prenez en compte les 2ème et 3ème paramètres ici.
40
Peter Bailey

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

En ce qui concerne les attaques par injection SQL, assurez-vous de vérifier l’entrée utilisateur, puis exécutez-la via mysql_real_escape_string (). La fonction ne supprimera toutefois 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.

21
jasonbar

PHP 5.2 a introduit la fonction filter_var.

Il supporte beaucoup de filtres SANITIZE, VALIDATE.

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

19
dangel

Une astuce qui peut aider dans les cas spécifiques où vous avez une page comme /mypage?id=53 et que vous utilisez l'id 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.)

15
Hamish Downer

Vous décrivez ici deux problèmes distincts: 

  1. Désinfection/filtrage des données d'entrée de l'utilisateur.
  2. Sortie d'échappement.

1) On doit toujours supposer que les entrées de l'utilisateur sont mauvaises.

Utiliser des instructions préparées, et/et filtrer avec mysql_real_escape_string est vraiment un must . PHP a également intégré filter_input qui est un bon point de départ.

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

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 PHP résultats

Sortie plus sûre PHP

10
Andrew

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

  • Utilisez les versions modernes de MySQL et PHP.

  • Définir explicitement charset:

    • $ mysqli-> set_charset ("utf8");
      Manuel
    • $ pdo = new PDO ('mysql: Host = localhost; dbname = testdb; charset = UTF8', $ utilisateur, $ mot de passe);
      Manuel
    • $ pdo-> exec ("noms de noms utf8");
      Manuel
    • $ pdo = new PDO (
 "mysql: Host = $ Host; nombase = $ db", $ utilisateur, $ pass, 
 array (
 PDO :: ATTR_ERRMODE => PDO :: ERRMODE_EXCEPTION, 
PDO :: MYSQL_ATTR_INIT_COMMAND => "FIXER LES NOMS utf8" 
) 
);
      Manuel
    • mysql_set_charset ('utf8')
      [obsolète dans PHP 5.5.0, supprimé dans PHP 7.0.0].

  • Utilisez 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.

  • Utilisez la fonction spatialisée:

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

    • PDO :: quote () - place des guillemets autour de la 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 guillemet approprié au pilote sous-jacent:

      $ pdo = new PDO ('mysql: Host = localhost; dbname = testdb; charset = UTF8', $ utilisateur, $ mot de passe);définir explicitement le jeu de caractères
      $ pdo-> setAttribute (PDO :: ATTR_EMULATE_PREPARES, false);désactive les instructions émulées préparées pour éviter le repli sur des instructions émulées que MySQL ne peut pas préparer en mode natif (pour empêcher l'injection)
      $ var = $ pdo-> quote ("'OR 1 = 1/*");non seulement échappe au littéral, mais le cite également (entre caractères 'guillemets simples)
 $ stmt = $ pdo-> requête ("SELECT * FROM test WHERE nom = $ var LIMIT 1");

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

      $ pdo = new PDO ('mysql: Host = localhost; dbname = testdb; charset = UTF8', $ utilisateur, $ mot de passe);définir explicitement le jeu de caractères
      $ pdo-> setAttribute (PDO :: ATTR_EMULATE_PREPARES, false);désactive les instructions émulées préparées pour éviter le repli sur des instructions émulées que MySQL ne peut pas préparer en mode natif (pour empêcher l'injection)
 $ stmt = $ pdo-> prepare ('SELECT * DE l'essai WHERE nom =? LIMIT 1'); 
 $ stmt-> execute (["'OR 1 = 1/*"] )

    •  mysql_real_escape_string [obsolète dans PHP 5.5.0, supprimé dans PHP 7.0.0].
    • mysqli_real_escape_string Échappe aux caractères spéciaux d'une chaîne pour les utiliser dans une instruction SQL, en 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, c'est une méthode optimisée.
    • Utilisez des guillemets simples ('') autour de vos variables dans votre requête.

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

    • Si vous attendez un entier, utilisez: .____.
      ctype_digit - Vérifie les caractères numériques;
      $ valeur = (int) $ valeur;
      $ value = intval ($ value);
      $ var = filter_var ('0755', FILTER_VALIDATE_INT, $ options);
    • Pour les chaînes, utilisez: 
      is_string () - Détermine si le type d'une variable est une chaîne

      Utiliser Fonction de filtre filter_var () - Filtre une variable avec un filtre spécifié:
      $ email = filter_var ($ email, FILTER_SANITIZE_EMAIL);
      $ newstr = filter_var ($ str, FILTER_SANITIZE_STRING);
      plus de filtres prédéfinis
    • filter_input () - Obtient une variable externe spécifique par son nom et la filtre éventuellement:
      $ search_html = filter_input (INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);
    • preg_match () - Effectue une correspondance d'expression régulière;
    • Écrivez votre propre fonction de validation.
8
Mark Martin

Si vous utilisez PostgreSQL, l'entrée de PHP peut être échappée avec pg_escape_string ()

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

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 retourne une chaîne échappée au format PostgreSQL sans les guillemets.

6
Alejandro Silva

Le moyen le plus simple d'éviter les erreurs de nettoyage des entrées et des données d'échappement consiste à utiliser un cadre 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 gabarit tel que Twig ou Latte a la sortie échappée par défaut - vous n'avez pas à résoudre manuellement si vous avez échappé correctement 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 frameworks ORM comme Doctrine ou des wrappers autour de PDO comme Nette Database.

Vous pouvez en lire plus ici - Qu'est-ce qu'un framework logiciel?

5
Ondřej Šotek

Il n'y a pas de fonction fourre-tout, car il y a plusieurs préoccupations à résoudre.

  1. Injection SQL - Aujourd'hui, en règle générale, chaque projet PHP doit utiliser des instructions préparées via PHP objets de données (PDO) , à titre de meilleure pratique, en évitant les erreurs citation parasite ainsi qu’une solution complète contre l’injection. C'est également le moyen le plus flexible et le plus sécurisé d'accéder à votre base de données. 

    Consultez (Le seul correct) tutoriel PDO pour à peu près tout ce que vous devez savoir sur PDO. (Merci sincèrement à SO, votre contributeur principal, @YourCommonSense, pour cette excellente ressource sur le sujet.)

  2. XSS - Désinfecte les données en cours de route ... 

    • HTML Purifier a été autour depuis longtemps et est toujours activement mis à jour. Vous pouvez l'utiliser pour supprimer les entrées malveillantes tout en permettant une liste blanche généreuse et configurable de balises. 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 ayant passé plusieurs audits contre XSS): 

      /* Prevent XSS input */ function sanitizeXSS () { $_GET = filter_input_array(INPUT_GET, FILTER_SANITIZE_STRING); $_POST = filter_input_array(INPUT_POST, FILTER_SANITIZE_STRING); $_REQUEST = (array)$_POST + (array)$_GET + (array)$_REQUEST; }

  3. XSS - Désinfectez les données avant de les supprimer ... sauf si vous garantissez que les données ont été correctement filtrées avant de les ajouter à votre base de données, vous devez les supprimer avant de les afficher à l'utilisateur, nous pouvons en tirer parti PHP fonctions: 

    • Lorsque vous appelez echo ou print pour afficher les valeurs fournies par l'utilisateur, utilisez htmlspecialchars sauf si les données ont été correctement filtrées et sont autorisées à afficher du code HTML.
    • json_encode est un moyen sûr de fournir des valeurs fournies par l'utilisateur de PHP à Javascript.

  4. Appelez-vous des commandes Shell externes à l’aide des fonctions exec() ou system() , ou de l’opérateur backtick ? Si tel est le cas, outre SQL Injection & XSS, vous avez peut-être un problème supplémentaire à résoudre, les utilisateurs exécutant des commandes malveillantes sur votre serveur. Vous devez utiliser escapeshellcmd si vous souhaitez échapper à la commande entière OR escapeshellarg pour échapper aux arguments individuels.

3
webaholik

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 vous protéger contre XSS, lisez ceci: OWASP Feuille de triche pour la prévention XSS

2
user138720

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

Vous désinfectez toujours la sortie.

Les transformations que vous appliquez aux données pour sécuriser leur inclusion dans une instruction SQL sont complètement différentes de celles que vous appliquez pour une inclusion en HTML, complètement différentes de celles que vous appliquez pour une inclusion en Javascript et totalement différentes de celles que vous appliquez pour une inclusion dans LDIF. 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 ....

Par tous les moyens validez l’entrée - décidez si vous devez l’accepter pour un traitement ultérieur ou dites à l’utilisateur que cela est inacceptable. Mais n'appliquez aucun changement à la représentation des données jusqu'à ce qu'elles 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 et nous nous sommes retrouvés avec " magic_quotes " qui n'échappait pas correctement les données pour toutes les cibles de sortie et aboutissait à une installation différente nécessitant un code différent pour travail.

1
symcbean

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

comme:

    $a=fliter_var($_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 les "'\ <> & et\0 afin que je puisse voir cela comme un bon moyen de désinfection. inclure ces autres caractères comme/{} [].; `renforcerait cette fonction sur la ligne encode (enc ['']]):

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

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;
0
Erik Thiart

Il y a l'extension filtre ( comment lier , manuel ), 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.

0
Till