Sécurité PHP (strip_tags, htmlentities)

Question

Je travaille dans un projet personnel et en plus d'utiliser des instructions préparées, je voudrais utiliser chaque entrée comme une menace. Pour cela j'ai fait une fonction simple.

function clean($input){ 
if (is_array($input)){ 
    foreach ($input as $key => $val){ 
     $output[$key] = clean($val); 
    } 
}else{ 
    $output = (string) $input; 
    if (get_magic_quotes_gpc()){ 
     $output = stripslashes($output); 
    } 
    $output = htmlentities($output, ENT_QUOTES, 'UTF-8'); 

} 
return $output; 
} 

Est-ce que cela est suffisant ou devrais-je utiliser pour le code suivant?

 $output = mysqli_real_escape_string($base, $input); 
     $output = strip_tags($output); 

Désolé, ce pourrait être une question stupide, mais je voudrais éviter tout problème avec moi le code :) Merci pour votre aide

Answer 1

Je salue vos efforts. Vous devez, membre de la communauté amicale, envisager de découpler vos opérations.

) Avoir une fonction/routine/class/Procédé de filtrage d'entrée (filter_input_array(), strip_tags(), str_ireplace(), trim(), etc ...). Vous pouvez créer des fonctions utilisant des boucles pour effectuer le filtrage. Des astuces telles que le double codage, l'usurpation de bande à usage unique et bien d'autres peuvent faire échec à l'usage unique de choses telles que strip_tags().

Voici une méthode wrapper strip_tags() de ma classe Sanitizer. Notez comment il compare l'ancienne valeur à la nouvelle valeur pour voir si elles sont égales. S'ils ne sont pas égaux, ils continuent à utiliser strip_tags(). Bien qu'il y ait un peu de vérification INPUT_POST/$ _POST préliminaire avant que cette méthode soit exécutée. Une autre version de ceci utilisant trim() est réellement exécutée avant celle-ci.

private function removeHtml(&$value) 
{  
    if (is_scalar($value)) { 
     do { 
      $old = $value; 
      $value = strip_tags($value); 

      if ($value === $old) { 
       break; 
      } 
     } while(1); 
    } else if (is_array($value) && !empty($value)) { 
     foreach ($value as $field => &$string) { 
      do { 
       $old = $string; 
       $string = strip_tags($string); 

       if ($string === $old) { 
        break; 
       } 
      } while (1); 
     } 
    } else { 
     throw new Exception('The data being HTML sanitized is neither scalar nor in an array.'); 
    } 

    return; 
} 

) Avoir un autre pour valider une entrée (filter_var_array(), preg_match(), mb_strlen, etc ...)

Ensuite, lorsque vos données doivent passer des contextes ...

A) Pour les bases de données, utiliser des instructions préparées (PDO, de préférence).

B) Pour le retour/transmission entrée utilisateur au navigateur, échapper à la sortie avec htmlentities() ou htmlspecialchars en conséquence.

En termes de citations magiques, la meilleure chose à faire est simplement de désactiver cela dans le php.ini.

Maintenant, avec ces différentes constructions ayant leurs propres domaines de responsabilité, tout ce que vous avez à faire est de gérer le flux de logique et de données à l'intérieur de votre fichier gestionnaire. Cela inclut la fourniture de messages d'erreur à l'utilisateur (si nécessaire) et la gestion des erreurs/exceptions.

Il n'y a pas besoin d'utiliser htmlentities() ou htmlspecialchars immédiatement si les données vont de la forme HTML directement dans la base de données. Le but de l'échappement des données est d'éviter qu'elles soient interprétées comme des instructions exécutables dans un nouveau contexte. Il n'y a aucun danger htmlentities() ou htmlspecialchars peut résoudre lors de la transmission de données à un moteur de requête SQL (c'est pourquoi vous filtrez et validez l'entrée, et utilisez les instructions préparées (PDO)).

Cependant, après que les données sont extraites de tables de base de données et est-directement destiné pour le navigateur, ok, utilisez maintenant htmlentities() ou htmlspecialchars. Créez un function qui utilise une boucle for ou foreach pour gérer ce scénario.

Voici un extrait de ma classe Escaper

public function superHtmlSpecialChars($html) 
{ 
    return htmlspecialchars($html, ENT_QUOTES | ENT_HTML5, 'UTF-8', false); 
} 

public function superHtmlEntities(&$html) 
{ 
    $html = htmlentities($html, ENT_QUOTES | ENT_HTML5, 'UTF-8', false); 
} 

public function htmlSpecialCharsArray(array &$html) 
{  
    foreach ($html as &$value) { 
     $value = $this->superHtmlSpecialChars($value); 
    } 

    unset($value); 
} 

public function htmlEntitiesArray(array &$html) 
{  
    foreach ($html as &$value) { 
     $this->superHtmlEntities($value); 
    } 

    unset($value); 
} 

Vous devez adapter votre code à vos propres goûts personnels et de la situation.

Notez, si vous envisagez de traiter les données avant de les envoyer au navigateur, effectuez d'abord le traitement, puis quittez avec votre fonction de bouclage pratique htmlentities() ou htmlspecialchars.

Vous pouvez le faire!

Answer 2

scénario d'utilisation pour les strip_tags() and htmlentities or htmlspecialchars().

1.) Si vous voulez dépouiller tous les éléments HTML à partir peut être saisie de formulaire qui peut être vulnérable à XSS attaque, puis utilisez strip_tags() fonction avant d'effectuer l'insertion à la base de données Exemple

$data= strip_tags('<b>Hello</b>'); 

Votre sortie sera "Bonjour" et c'est ce qui sera transmis au serveur. 2. Si vous souhaitez imprimer des données sur le navigateur ou l'écran, vous pouvez utiliser htmlentities() or htmlspecialchars() ci-dessous est un scénario utilisé où il peut être utilisé.

//DB PDO Connect.... 
$result2 = $db->prepare('select * from users where uid=:uid'); 
     $result2->execute(array(':uid' =>'1')); 

while ($row = $result2->fetch()) { 


$pic=htmlentities($row['profilepic'], ENT_QUOTES, "UTF-8"); 
} 

Vous pouvez ensuite imprimer pic $ partout où vous voulez et être libre de XSS attaque ....