Wie kann ich Benutzereingaben mit PHP sanieren?

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

Frage

Gibt es eine Catch-All-Funktion irgendwo, die für SQL-Injection und XSS-Angriffe gut zum Sterilisieren von Benutzereingaben arbeitet, während nach wie vor bestimmte Arten von HTML-Tags erlaubt?

War es hilfreich?

Lösung

Es ist ein verbreiteter Irrtum, dass Benutzereingaben gefiltert werden können. PHP hat sogar einen (jetzt veraltet) „Funktion“, die so genannte Zauber-Zitate, die auf dieser Idee baut. Das ist Unsinn. Vergessen Sie Filterung (oder Reinigung, oder was auch immer Leute nennen es).

Was Sie tun sollten, um Probleme zu vermeiden, ist ganz einfach: wenn Sie eine Zeichenfolge in fremden Code einbetten, müssen Sie es entkommen, nach den Regeln dieser Sprache. Zum Beispiel, wenn Sie eine Zeichenfolge in einigen SQL-Targeting MySql einbetten, müssen Sie die Zeichenfolge mit dem MySQL-Funktion für diesen Zweck (mysqli_real_escape_string) entkommen. (Oder, im Fall von Datenbanken, mit Prepared Statements sind ein besserer Ansatz wird, wenn möglich)

Ein weiteres Beispiel ist HTML: Wenn Sie Zeichenfolgen in HTML-Markup einbinden, müssen Sie entkommen mit htmlspecialchars . Das bedeutet, dass jeder einzelne echo oder print Anweisung sollte htmlspecialchars verwenden.

Ein drittes Beispiel könnte Shell-Befehle sein: Wenn Sie Zeichenfolgen (wie Argumente) auf externe Befehle werden einzubetten, und nennen sie mit exec , dann müssen Sie verwenden escapeshellcmd und escapeshellarg .

Und so weiter und so fort ...

Die nur Fall, in dem Sie benötigen, um aktiv Daten zu filtern, ist, wenn Sie vorformatierte Eingang sind zu akzeptieren. Z.B. wenn Sie lassen Sie Ihre Benutzer veröffentlichen HTML-Markup, dass Sie auf der Website angezeigt werden möchten. Sie sollten jedoch sinnvoll sein, diese um jeden Preis zu vermeiden, da, egal wie gut Sie sie filtern, es wird immer ein potenzielles Sicherheitsloch sein.

Andere Tipps

Versuchen Sie nicht, SQL-Injection zu verhindern, indem Eingangsdaten Hygienisierung.

Stattdessen keine Daten ermöglichen bei der Erstellung Ihrer SQL-Code verwendet werden. Verwendung hergestellt Statements (das heißt unter Verwendung von Parametern in einem Template query), die gebunden Variablen verwendet. Es ist der einzige Weg, garantiert gegen SQL-Injektion werden.

Sie bitte meine Website http://bobby-tables.com/ für mehr über das Verhindern von SQL-Injektion.

Nein. Sie können nicht generell Daten filtern, ohne Kontext dessen, was es ist. Manchmal würden Sie eine SQL-Abfrage als Eingabe nehmen und manchmal würden Sie HTML als Eingabe nehmen wollen.

Sie müssen sich auf einer weißen Liste Eingabe filtern - sicherzustellen, dass die Daten eine Spezifikation übereinstimmt, was Sie erwarten. Dann müssen Sie es entkommen, bevor Sie es benutzen, je nach Kontext, in dem Sie es verwenden.

Die Prozessdaten für SQL entkommen - SQL-Injection zu verhindern -. Ist sehr verschieden von den Prozessdaten zu entkommen für (X) HTML, XSS zu verhindern

hat PHP die neuen schönen filter_input Funktionen jetzt, dass Sie zum Beispiel befreit von der Suche jetzt ‚die ultimative E-Mail regex‘, dass es ein eingebaute in FILTER_VALIDATE_EMAIL Typ ist

Meine eigene Filterklasse (nutzt Javascript fehlerhafte Felder markieren) kann entweder durch eine Ajax-Anforderung oder Normalform Post eingeleitet werden. (Siehe Beispiel unten)      

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



}

Natürlich, denken Sie daran, dass Sie benötigen, um Ihre SQL-Abfrage tun zu entkommen, je nachdem, welche Art von db Ihre verwenden (mysql_real_escape_string () ist für einen SQL-Server zum Beispiel nutzlos). Wahrscheinlich wollen Sie diese automatisch an Ihre entsprechenden Anwendungsschicht wie ein ORM zu handhaben. Auch, wie oben erwähnt: zu html Ausgabe die andere PHP gewidmet Funktionen wie htmlspecialchars verwenden;)

Für wirklich HTML-Eingabe mit wie gestrippt Klassen ermöglichen und / oder Tags ist abhängig von einem der dedizierten xss Validierungspakete. Sie nicht Ihre eigene reguläre Ausdrücke SCHREIBEN HTML parsen!

Nein, es ist nicht.

Zu allererst SQL-Injection ist eine Eingangsfilterung Problem, und XSS ist eine Ausgabe einer Flucht -. So würden Sie diese beiden Operationen zur gleichen Zeit in den Code-Lebenszyklus nicht einmal ausführen

Grundfaustregeln

  • Für SQL-Abfrage, binden Parameter (wie bei PDO) oder verwenden Sie eine Treiber-native für Query-Variablen (wie mysql_real_escape_string()) entweichende Funktion
  • Verwenden Sie strip_tags() zum Ausfiltern von unerwünschten HTML
  • Escape alle anderen Ausgang mit htmlspecialchars() und darauf achten, den 2. und 3. Parameter hier.

die XSS Problem zu adressieren, werfen Sie einen Blick auf HTML Purifier . Es ist ziemlich konfigurierbar und hat eine gute Erfolgsbilanz.

Wie bei den Injection-Angriffe SQL, stellen Sie sicher, dass Sie die Benutzereingabe zu überprüfen, und führen Sie es dann allerdings mysql_real_escape_string (). Die Funktion wird nicht alles Injection-Angriffe besiegen, aber so ist es wichtig, dass Sie die Daten überprüfen, bevor es in der Query-String-Dumping.

Eine bessere Lösung ist bereit, Aussagen zu verwenden. Die PDO Bibliothek und mysqli-Erweiterung unterstützt diese.

PHP 5.2 eingeführt, um die filter_var Funktion.

Es viel sanieren unterstützt, Validieren Filter.

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

Ein Trick, der in den spezifischen Umständen helfen kann, wo Sie eine Seite wie /mypage?id=53 haben und Sie die ID in einem WHERE-Klausel, dass die ID auf jeden Fall, um sicherzustellen, ist eine ganze Zahl, etwa so: 

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

Aber das ist natürlich nur einen bestimmten Angriff schneidet, so lesen Sie alle anderen Antworten. (Und ja, ich weiß, dass der obige Code ist nicht groß, aber es zeigt die spezifische Abwehr.)

  

Methoden zur Hygienisierung von Benutzereingaben mit PHP:

  • Mit modernen Versionen von MySQL und PHP.

  • Set charset explizit: 

    • $mysqli->set_charset("utf8");
      Handbuch 
    • $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);
      Handbuch 
    • $pdo->exec("set names utf8");
      Handbuch 
    • $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"
)
);
      Handbuch 
    • mysql_set_charset('utf8')
      [veraltet in PHP 5.5.0, entfernt in PHP 7.0.0].

  • Benutzen Sie eine sichere charsets:

    • Wählen Sie UTF-8, latin1, ascii .., nicht anfällig charsets big5, cp932 verwenden, GB2312, GBK, sjis.

  • Mit verräumlicht Funktion:

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

    • PDO :: quote () - setzt Anführungszeichen um die Eingabestring (falls erforderlich) und entkommt Sonderzeichen innerhalb der Eingabezeichenfolge, eine Angabe Stil entsprechend den zugrunde liegenden Treiber: 

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

    • PDO Prepared Statements : vs MySQLi Aussagen bereit, mehr Datenbank unterstützt Treiber und benannte Parameter: 

      $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 [veraltet in PHP 5.5.0, entfernt in PHP 7.0.0].
    • mysqli_real_escape_string Maskiert spezielles Zeichen in einer Zeichenfolge für den Einsatz in eine SQL-Anweisung, unter Berücksichtigung der aktuellen charset der Verbindung. Aber empfohlen Prepared Statements zu verwenden, da sie nicht nur Strings entkommen, eine Aussage kommt mit einem kompletten Abfrageausführungsplan, einschließlich, die Tabellen und Indizes es benutzen würde, ist es eine optimierte Art und Weise.
    • Benutzen Sie (‘‚) um Ihre Variablen in Ihrer Abfrage.

  • Überprüfen Sie die Variable enthält, was man erwartet für:

    • Wenn Sie eine ganze Zahl erwarten, verwenden: 
      ctype_digit — Check for numeric character(s);
      $value = (int) $value;
      $value = intval($value);
      $var = filter_var('0755', FILTER_VALIDATE_INT, $options);
    • For Strings Verwendung: 
      is_string() — Find whether the type of a variable is string

      Verwenden Filterfunktion filter_var () - filtert eine Variable mit einer bestimmten Filter: 
      $email = filter_var($email, FILTER_SANITIZE_EMAIL);
      $newstr = filter_var($str, FILTER_SANITIZE_STRING);
      mehrere vordefinierte Filter
    • filter_input () - Ruft eine bestimmte externe Variable mit Namen und filtert sie optional: 
      $search_html = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);
    • preg_match () - Führen Sie einen regulären Ausdruck;
    • Schreiben Sie Ihre eigene Validierungsfunktion.

Was Sie beschreiben hier zwei getrennte Fragen:

  1. Sanitizing / Filterung von Benutzereingabedaten.
  2. Escaping Ausgabe.

1) Benutzereingabe sollte immer davon ausgegangen werden, schlecht sein.

Mit Prepared Statements oder / und Filterung mit mysql_real_escape_string ist auf jeden Fall ein Muss. PHP hat auch filter_input gebaut, in dem ein guter Anfang.

Dieses

2) ist ein großes Thema, und es hängt vom Kontext der Daten ausgegeben werden. Bei HTML gibt es Lösungen, wie HTMLPurifier gibt. als Faustregel, Flucht immer alles, was Sie ausgegeben.

Beiden Probleme sind viel zu groß, um in in einem einzigen Post zu gehen, aber es gibt viele Stellen, die mehr ins Detail gehen:

Methoden PHP Ausgabe

Safer PHP Ausgabe

Wenn Sie PostgreSQL verwenden, kann die Eingabe von PHP mit pg_escape_string entwertet werden () 

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

Aus der Dokumentation ( http://php.net/manual /es/function.pg-escape-string.php ):

  

pg_escape_string () einen String für die Datenbank abfragt. Es gibt einen maskierten String in dem PostgreSQL-Format ohne Anführungszeichen.

Der einfachste Weg, um Fehler zu vermeiden Eingabe in desinfizierende und Daten entweichende mit PHP Framework wie Symfony , Netter usw. oder ein Teil dieses Rahmens (Template-Engine, Datenbankschicht, ORM).

Templating Engine wie Zweig oder Latte ausgegeben hat standardmäßig auf Flucht - Sie müssen nicht lösen manuell, wenn Sie Ihren Ausgang richtig entkommen je nach Kontext (HTML oder Javascript Teil der Web-Seite).

Framework automatisch Eingang Hygienisierung und Sie should't direkt $ _POST, $ _GET oder $ _SESSION Variablen verwenden, aber durch Mechanismus wie Routing, Sitzung usw. Handhabung.

Für eine Datenbank (Modell) Schicht gibt es ORM-Frameworks wie Lehre oder Wrapper um PDO wie Nette Datenbank.

Sie können mehr darüber lesen Sie hier - Was für ein Software-Framework ist?

Es gibt keine catchall Funktion, denn es gibt mehrere Probleme angesprochen werden sollen.

  1. SQL Injection - Heute ist jedes PHP-Projekt sollte in der Regel, sein mit Prepared Statements über PHP Data Objects (PDO) als best Practice, einen Fehler von einem Streu Zitat zu verhindern sowie eine voll funktionsfähige Lösung gegen Injektion . Es ist auch die flexibelste und sichere Art und Weise Ihre Datenbank zuzugreifen.

    Schauen Sie sich (Der einzig richtige) PDO Tutorial für so ziemlich alles, was Sie müssen über PDO kennen. (Herzlicher Dank nach oben SO mitwirkender, @YourCommonSense, für diese große Ressource zu diesem Thema.)

  2. XSS - Desinfizieren Sie Daten auf dem Weg in ...

    • HTML Purifier hat sich um eine lange Zeit gewesen und immer noch aktiv aktualisiert. Sie können es verwenden bösartigen Eingang zu sanieren, während immer noch eine großzügige und konfigurierbare Whitelist von Tags erlaubt. Funktioniert hervorragend mit vielen WYSIWYG-Editoren, aber es könnte für einige Anwendungsfälle.

      • schwer sein

    • In anderen Fällen, in denen wir nicht wollen, HTML akzeptieren / Javascript überhaupt, habe ich diese einfache Funktion nützlich gefunden (und hat mehrere Prüfungen gegen XSS bestanden):

      /* 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 - Desinfizieren Sie Daten auf dem Weg ... aus , wenn Sie die Daten garantieren korrekt desinfiziert wurde, bevor Sie es zu Ihrer Datenbank hinzufügen, müssen Sie es sanieren, bevor diese angezeigt Ihren Benutzer, können wir diese nützlichen PHP-Funktionen nutzen:

    • Wenn Sie echo oder print rufen Benutzer gelieferten Werte anzuzeigen, verwenden Sie htmlspecialchars es sei denn, die Daten wurden ordnungsgemäß sicher desinfiziert und darf HTML angezeigt werden soll.
    • json_encode ist eine sichere Art und Weise vom Benutzer angegebenen Werte zur Verfügung zu stellen von PHP Javascript

  4. Haben Sie externe Shell-Befehle rufen mit exec() oder system() Funktionen oder auf die backtick Operator? Wenn zusätzlich zu SQL Injection & XSS so, könnten Sie eine zusätzliche haben Sorge um Adresse, Benutzer, die schädliche Befehle auf dem Server . Sie müssen verwenden escapeshellcmd , wenn Sie möchten, dass der gesamte Befehl entkommen OR escapeshellarg einzelne Argumente zu entkommen.

Traue niemals Benutzerdaten. 

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

Die trim() Funktion entfernt Leerzeichen und andere vordefinierte Zeichen von beiden Seiten einer Zeichenkette.

Die stripslashes() Funktion entfernt Schrägstriche

Die htmlspecialchars() Funktion wandelt einige vordefinierte Zeichen in HTML-Entitäten.

Die vordefinierten Zeichen sind: 

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

Ich wollte nur, dass Flucht zum Thema Ausgabe hinzuzufügen, wenn Sie PHP DOMDocument verwenden, um Ihre HTML-Ausgabe machen es wird automatisch in den richtigen Kontext zu entkommen. Ein Attribut (value = „“) und der innere Text eines ist nicht gleich. Um sicher zu sein gegen XSS dies lesen: OWASP XSS Prävention Spickzettel

Sie sanieren nie Eingang.

Sie sanieren immer ausgegeben.

Die Transformationen Sie auf Daten angewendet, um es für die Aufnahme in einer SQL-Anweisung sicher zu machen sind völlig verschieden von denen, die Sie für die Aufnahme in HTML gelten sind völlig verschieden von denen, die Sie für die Aufnahme in Javascript gelten sind völlig verschieden von denen, die Sie für die Aufnahme beantragen in LDIF sind von den ganz anderen völlig verschieden von denen, die Sie für die Aufnahme in CSS anzuwenden sind Sie für die Aufnahme in einer E-Mail bewerben ....

Mit allen Mitteln Eingabe validieren - entscheiden, ob Sie es für die weitere Verarbeitung übernehmen soll oder dem Benutzer sagen, dass es nicht akzeptabel ist. Aber gelten keine Änderung Darstellung der Daten, bis er über PHP Land zu verlassen.

Vor langer Zeit jemand versucht, eine one-size zu erfinden passt alle Mechanismus für Daten zu entkommen und am Ende haben wir mit „ magic_quotes “die eigentlich keine Daten für alle Ausgabeziele entkommen und führte zu verschiedenen Installations anderen Code erfordern zu arbeiten.

Es ist der Filter-Erweiterung ( howto-link , Handbuch ), die mit allen GPC Variablen ziemlich gut funktioniert. Es ist keine Magie-do-it-all Sache aber, werden Sie noch, es zu benutzen haben.

Ich kann PHP-Filter sanieren spezielle Sonderzeichen kommen in praktisch sehen.

wie: 

    $a=fliter_var($_POST['a'],FILTER_SANITIZE_SPECIAL_CHARS);

Doch durch Lager, ich denke, es könnte besser sein, denn bei dem C-Code suchen, nur die Filter " '\ <> & und \ 0, so kann ich dies ein guter Weg zum Sterilisieren sein sehen. Allerdings änderte der Quellcode diese Zeichen enthalten wie / {} []; `diese Funktion stärken würde auf der encode (enc [ '']) Zeile:. 

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

Die beste BASIC-Methode für Benutzereingaben mit PHP Hygienisierung: 


    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;
    }
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top