Wie kann ich Benutzereingaben mit PHP bereinigen?

Gibt es irgendwo eine Catchall-Funktion, die gut funktioniert, um Benutzereingaben für SQL-Injection und XSS-Angriffe zu bereinigen und gleichzeitig bestimmte Arten von HTML-Tags zulässt?

Es ist ein weit verbreiteter Irrglaube, dass Benutzereingaben gefiltert werden können. PHP hat sogar ein (jetzt veraltetes) “Feature”, genannt Zauberzitate, die auf dieser Idee aufbaut. Das ist Unsinn. Vergessen Sie das Filtern (oder Reinigen oder wie auch immer die Leute es nennen).

Was Sie tun sollten, um Probleme zu vermeiden, ist ganz einfach: Wenn Sie ein Datenelement in einen fremden Code einbetten, müssen Sie es gemäß den Formatierungsregeln dieses Codes behandeln. Aber Sie müssen verstehen, dass solche Regeln zu kompliziert sein könnten, um zu versuchen, sie alle manuell zu befolgen. Beispielsweise sind in SQL die Regeln für Zeichenfolgen, Zahlen und Bezeichner alle unterschiedlich. Zu Ihrer Bequemlichkeit gibt es in den meisten Fällen ein spezielles Tool für eine solche Einbettung. Wenn Sie beispielsweise eine PHP-Variable in der SQL-Abfrage verwenden müssen, müssen Sie eine vorbereitete Anweisung verwenden, die sich um die gesamte richtige Formatierung/Behandlung kümmert.

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

Ein drittes Beispiel könnten Shell-Befehle sein: Wenn Sie Zeichenfolgen (z. B. Argumente) in externe Befehle einbetten und sie mit aufrufen execdann müssen Sie verwenden escapeshellcmd und escapeshellarg.

Ein sehr überzeugendes Beispiel ist auch JSON. Die Regeln sind so zahlreich und kompliziert, dass Sie sie niemals alle manuell befolgen könnten. Deshalb sollten Sie niemals einen JSON-String manuell erstellen, sondern immer eine dedizierte Funktion verwenden, json_encode() Dadurch wird jedes Datenbit korrekt formatiert.

Und so weiter und so fort …

Die nur Der Fall, in dem Sie Daten aktiv filtern müssen, ist, wenn Sie vorformatierte Eingaben akzeptieren. Wenn Sie beispielsweise zulassen, dass Ihre Benutzer HTML-Markup posten, das Sie auf der Website anzeigen möchten. Sie sollten dies jedoch um jeden Preis vermeiden, denn egal wie gut Sie es filtern, es wird immer eine potenzielle Sicherheitslücke sein.

Versuchen Sie nicht, die SQL-Injection zu verhindern, indem Sie Eingabedaten bereinigen.

Stattdessen, Lassen Sie nicht zu, dass Daten beim Erstellen Ihres SQL-Codes verwendet werden. Verwenden Sie vorbereitete Anweisungen (dh mit Parametern in einer Vorlagenabfrage), die gebundene Variablen verwenden. Dies ist die einzige Möglichkeit, um gegen SQL-Injection geschützt zu sein.

Bitte sehen Sie sich meine Website an http://bobby-tables.com/ Weitere Informationen zum Verhindern von SQL-Injection finden Sie hier.

Nein. Sie können Daten nicht generisch filtern, ohne dass sie im Zusammenhang mit dem Zweck stehen. Manchmal möchten Sie eine SQL-Abfrage als Eingabe verwenden, und manchmal möchten Sie HTML als Eingabe verwenden.

Sie müssen die Eingaben auf einer Whitelist filtern – stellen Sie sicher, dass die Daten mit einer Spezifikation Ihrer Erwartungen übereinstimmen. Dann müssen Sie es entkommen, bevor Sie es verwenden, je nach Kontext, in dem Sie es verwenden.

Der Prozess des Daten-Escapes für SQL – um eine SQL-Einschleusung zu verhindern – unterscheidet sich stark vom Prozess des Escapes von Daten für (X)HTML, um XSS zu verhindern.

PHP hat das neue nice filter_input Funktionen jetzt, die Sie zum Beispiel davon befreien, ‘die ultimative E-Mail-Regex’ zu finden, jetzt, wo es eine eingebaute gibt FILTER_VALIDATE_EMAIL Art

Meine eigene Filterklasse (verwendet JavaScript, um fehlerhafte Felder hervorzuheben) kann entweder durch eine Ajax-Anfrage oder einen normalen Formularpost initiiert 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');
 *  $sanitize = array('alias');
 *
 *  $validator = new FormValidator($validations, $required, $sanitize);
 *                  
 *  if($validator->validate($_POST))
 *  {
 *      $_POST = $validator->sanitize($_POST);
 *      // now do your saving, $_POST has been sanitized.
 *      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 sanitize just one element:
 * $sanitized = new FormValidator()->sanitize('<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->sanitations = $sanitations;
        $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);
    }


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


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

    /**
     *
     * Sanitize a single var according to $type.
     * Allows for static calling to allow simple sanitization
     */
    public static function sanitizeItem($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;
    }       
    


}

Denken Sie natürlich daran, dass Sie Ihre SQL-Abfrage auch entkommen müssen, je nachdem, welche Art von Datenbank Sie verwenden (mysql_real_escape_string() ist beispielsweise für einen SQL-Server nutzlos). Wahrscheinlich möchten Sie dies automatisch auf Ihrer entsprechenden Anwendungsebene wie einem ORM handhaben. Außerdem, wie oben erwähnt: Verwenden Sie für die Ausgabe in HTML die anderen dedizierten PHP-Funktionen wie htmlspecialchars 😉

Um HTML-Eingaben mit ähnlich entfernten Klassen und/oder Tags wirklich zuzulassen, hängen Sie von einem der dedizierten xss-Validierungspakete ab. SCHREIBEN SIE KEINE EIGENEN REGEXES, UM HTML ZU PARSEN!

Nein, da ist kein.

Zunächst einmal ist die SQL-Einschleusung ein Eingabefilterungsproblem, und XSS ist ein Ausgabe-Escape-Problem – Sie würden diese beiden Operationen also nicht einmal gleichzeitig im Code-Lebenszyklus ausführen.

Grundlegende Faustregeln

• Binden Sie für SQL-Abfragen Parameter (wie bei PDO) oder verwenden Sie eine treibernative Escape-Funktion für Abfragevariablen (wie z mysql_real_escape_string())
• Verwenden strip_tags() um unerwünschtes HTML herauszufiltern
• Escape alle anderen Ausgaben mit htmlspecialchars() und achten Sie hier auf den 2. und 3. Parameter.

Um das XSS-Problem zu lösen, werfen Sie einen Blick auf HTML-Reiniger. Es ist ziemlich konfigurierbar und hat eine anständige Erfolgsbilanz.

Stellen Sie bei den SQL-Injection-Angriffen sicher, dass Sie die Benutzereingabe überprüfen und sie dann durch mysql_real_escape_string() ausführen. Die Funktion wird jedoch nicht alle Injektionsangriffe abwehren, daher ist es wichtig, dass Sie die Daten überprüfen, bevor Sie sie in Ihre Abfragezeichenfolge einspeisen.

Eine bessere Lösung ist die Verwendung vorbereiteter Anweisungen. Die PDO-Bibliothek und mysqli-Erweiterung unterstützen diese.

PHP 5.2 führte das ein filter_var Funktion.

Es unterstützt sehr viel SANITIZE, VALIDATE Filter.