Bu kullanıcı girişi filtre edilebilir bir kanı var. PHP Hatta bu fikir üzerine inşa magic-tırnak denilen (şimdi artık) "özelliği", vardır. Bu saçmalık. Filtreleme (Ya temizlik, ya da ne olursa olsun insanlar onu aramak) unutun.

Ne sorunları önlemek için, yapmanız gereken oldukça basit: Eğer yabancı kodunun içinde bir dize embed zaman, o dilin kurallarına göre, onu kaçmak gerekir. Eğer MySQL hedefleme bazı SQL bir dize gömmek Örneğin, bu amaçla MySQL fonksiyonu ile dize (mysqli_real_escape_string ) kaçmak gerekir.

Başka bir örnek HTML: HTML işaretleme içindeki dizeleri embed varsa, htmlspecialchars . This means that every single echo veya print deyimi kullanmak gerekir ile kaçmak gerekir htmlspecialchars .

Üçüncü bir örnek kabuk komutları olabilir: Eğer dış komutlara (Bu argüman olarak) dizeleri gömmek, ve exec , then you must use escapeshellcmd and escapeshellarg onları aramak için gidiyoruz < / a>.

Giriş verileri sterilize SQL enjeksiyonu önlemek için çalışmayın.

Bunun yerine, do not allow data to be used in creating your SQL code. Bağlı değişkenleri kullanır parametreli SQL kullanın. Bu, SQL enjeksiyon karşı garantili olması tek yoldur.

Web siteme http://bobby-tables.com/ SQL enjeksiyon önleme hakkında daha fazla bilgi için bakınız.

Hayır jenerik bunun için ne herhangi bir bağlam olmadan verilere filtre olamaz. Bazen giriş olarak bir SQL sorgusu almak isterdim ve bazen girdi olarak HTML almak isterdim.

Sen beyaz liste üzerinde girişini süzmek gerekiyor - veri beklediğiniz bazı özelliklerine uygun olduğundan emin olun. Sonra bunu kullanarak hangi bağlam bağlı olarak, bunu kullanmak önce kaçmak gerekir.

SQL enjeksiyonu önlemek için - - SQL veri kaçan süreci XSS önlemek için, (X) HTML veri kaçan sürecinde çok farklıdır.

PHP Örneğin şimdi olduğu 'nihai bir e-posta regex' bulma sizi kurtarmak olduğunu, şimdi yeni güzel filter_input fonksiyonlara sahip yerleşik bir FILTER_VALIDATE_EMAIL tipi

My own filter class (uses javascript to highlight faulty fields) can be initiated by either an ajax request or normal form post. (see the example below)

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



}

Tabii ki, sizin SQL sorgusu (mysql_real_escape_string () örneği için bir SQL Server için yararsız) kullanarak db ne tür bağlı olarak çok kaçan yapmanız gerektiğini unutmayın. Muhtemelen bir ORM gibi uygun uygulama katmanında otomatik olarak bu işlemek istiyorum. Ayrıca, yukarıda da belirtildiği gibi: html için çıkış için htmlspecialchars'ın ;) gibi diğer php özel işlevleri kullanabilirsiniz

Gerçekten izin için gibi elimden sınıfları ve / veya etiketleri ile HTML giriş adanmış xss doğrulama paketlerinden birine bağlıdır. HTML ayrıştırmak için kendi Regexes YAZIN YAPMAYIN!

Hayır, yok.

Her şeyden önce, SQL injection bir giriş filtreleme sorundur ve XSS birini kaçan bir çıkış - yani bile kod yaşam döngüsü içinde aynı zamanda bu iki işlemlerini yürütmek olmaz.

Başparmak temel kuralları

• SQL sorgusu için, bağlama (PDO gibi) parametreleri veya (örneğin mysql_real_escape_string() gibi) sorgu değişkenleri için bir sürücü yerli kaçan işlevini kullanın
• strip_tags() istenmeyen HTML filtrelemek için kullanın
• htmlspecialchars() ile diğer tüm çıkış kaçmak ve burada 2. ve 3. parametrelerinin dikkatli olun.

XSS sorunu gidermek için, HTML Purifier bakabilirsiniz. Bu oldukça yapılandırılabilir ve iyi bir sicili vardır.

) SQL enjeksiyon saldırıları gelince, emin kullanıcı girişi kontrol yapmak, ve sonra (mysql_real_escape_string olsa çalıştırın. Işlevi olsa da, tüm enjeksiyon saldırıları yenilgi olmaz, bu yüzden sizin sorgu dizesi içine damping önce verileri kontrol etmeniz önemlidir.

Daha iyi bir çözüm hazırlanmış deyimleri kullanmaktır. PDO library ve mysqli uzantısı desteği bu.

Eğer /mypage?id=53 gibi bir sayfa var ve kesinlikle bu kimliği sağlamak için yan tümcesi WHERE bir de id kullanarak belirli koşulda yardımcı olabilir Bir hile böylece gibi, bir tam sayıdır:

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

Ama tabii sadece belirli bir saldırıyı keser, böylece diğer tüm cevapları okudum ki. (Ve evet ben yukarıdaki kodu büyük olmadığını biliyorum, ama bu özel savunma gösterir.)

PHP 5.2 filter_var fonksiyonunu tanıttı.

Bu filtreler DOĞRULAYıN, sterilize büyük bir destekler.

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

Burada ne açıklayan iki ayrı konulardır:

1. Kullanıcı veri girişi sterilize / filtreleme.
2. Kaçış çıktı.

1) Kullanıcı girişi daima kötü olarak kabul edilmelidir.

Using prepared statements, or/and filtering with mysql_real_escape_string is definitely a must. PHP also has filter_input built in which is a good place to start.

2) This is a large topic, and it depends on the context of the data being output. For HTML there are solutions such as htmlpurifier out there. as a rule of thumb, always escape anything you output.

Hem sorunları tek bir yazı girmek için çok büyük, ama daha fazla detaya mesajların çok var:

Methods PHP output

Safer PHP output

Tüm GPC değişkenler ile oldukça iyi çalışır filtresi uzantısı (howto-link, manual), vardır. Ama sihirli bir-do-it-all şey değil, sen hala kullanmak zorunda olacak.