PHP के साथ उपयोगकर्ता इनपुट को स्वच्छ करने के लिए सबसे अच्छी विधि क्या है?




security xss (12)

क्या वहां कोई कैचल फ़ंक्शन है जो एसक्यूएल इंजेक्शन और एक्सएसएस हमलों के लिए उपयोगकर्ता इनपुट को स्वच्छ करने के लिए अच्छी तरह से काम करता है, जबकि अभी भी कुछ प्रकार के एचटीएमएल टैग की अनुमति है?


PHP के साथ उपयोगकर्ता इनपुट को स्वच्छ करने के तरीके:

  • MySQL और PHP के आधुनिक संस्करणों का प्रयोग करें।

  • वर्णमाला को स्पष्ट रूप से सेट करें:

    • $mysqli->set_charset("utf8");
      manual
    • $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);
      manual
    • $pdo->exec("set names utf8");
      manual
    • $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"
      )
      );
      manual
    • mysql_set_charset('utf8')
      [PHP 5.5.0 में बहिष्कृत, PHP 7.0.0 में हटा दिया गया]।
  • सुरक्षित वर्णमाला का प्रयोग करें:

    • Utf8, latin1, ascii .. का चयन करें, कमजोर वर्णमाला big5, cp932, gb2312, gbk, sjis का उपयोग न करें।
  • स्थानिक कार्य का प्रयोग करें:

    • MySQLi तैयार बयान:
      $stmt = $mysqli->prepare('SELECT * FROM test WHERE name = ? LIMIT 1'); 
      $param = "' OR 1=1 /*";
      $stmt->bind_param('s', $param);
      $stmt->execute();
    • PDO::quote() - अंतर्निहित चालक के लिए उपयुक्त उद्धरण शैली का उपयोग करके, इनपुट स्ट्रिंग के आस-पास स्थान उद्धरण (यदि आवश्यक हो) और इनपुट स्ट्रिंग के भीतर विशेष वर्णों से बच निकलता है:

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

    • पीडीओ तैयार वक्तव्य : बनाम MySQLi तैयार कथन अधिक डेटाबेस ड्राइवरों और नामित पैरामीटर का समर्थन करता है:

      $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 [PHP 5.5.0 में बहिष्कृत, PHP 7.0.0 में हटा दिया गया]।
    • mysqli_real_escape_string कनेक्शन के वर्तमान अक्षर को ध्यान में रखते हुए SQL कथन में उपयोग के लिए स्ट्रिंग में विशेष वर्णों से बच mysqli_real_escape_string । लेकिन तैयार वक्तव्यों का उपयोग करने की अनुशंसा की जाती है क्योंकि वे स्ट्रिंग से बच नहीं पाए जाते हैं, एक बयान पूरी क्वेरी निष्पादन योजना के साथ आता है, जिसमें कौन सी टेबल और इंडेक्स इसका उपयोग करेंगे, यह एक अनुकूलित तरीका है।
    • अपनी क्वेरी के अंदर अपने चर के चारों ओर सिंगल कोट्स ('') का प्रयोग करें।
  • वैरिएबल की जांच करें जिसमें आप उम्मीद कर रहे हैं:

    • यदि आप पूर्णांक की अपेक्षा कर रहे हैं, तो इसका उपयोग करें:
      ctype_digit — Check for numeric character(s);
      $value = (int) $value;
      $value = intval($value);
      $var = filter_var('0755', FILTER_VALIDATE_INT, $options);
    • स्ट्रिंग्स के लिए उपयोग करें:
      is_string() — Find whether the type of a variable is string

      फ़िल्टर फ़ंक्शन का उपयोग करें filter_var () - एक निर्दिष्ट फ़िल्टर के साथ एक चर फ़िल्टर करें:
      $email = filter_var($email, FILTER_SANITIZE_EMAIL);
      $newstr = filter_var($str, FILTER_SANITIZE_STRING);
      अधिक पूर्वनिर्धारित फिल्टर
    • filter_input() - नाम से एक विशिष्ट बाहरी चर प्राप्त करता है और वैकल्पिक रूप से इसे फ़िल्टर करता है:
      $search_html = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);
    • preg_match() - एक नियमित अभिव्यक्ति मैच करें;
    • अपना खुद का सत्यापन समारोह लिखें।

आपने इनपुट को कभी भी स्वच्छ नहीं किया है।

आप हमेशा आउटपुट को स्वच्छ करते हैं।

एसक्यूएल कथन में शामिल करने के लिए इसे सुरक्षित बनाने के लिए डेटा पर लागू होने वाले परिवर्तन एचटीएमएल में शामिल करने के लिए आवेदन करने वाले लोगों से पूरी तरह अलग हैं, जो आप जावास्क्रिप्ट में शामिल करने के लिए आवेदन करने वालों से बिल्कुल अलग हैं, जो आप एलडीआईएफ में शामिल करने के लिए आवेदन करते हैं, उससे बिल्कुल अलग हैं सीएसएस में शामिल करने के लिए आवेदन करने वाले लोगों से बिल्कुल अलग है, जो आप ईमेल में शामिल करने के लिए आवेदन करते हैं उससे बिल्कुल अलग हैं ....

हर तरह से इनपुट प्रमाणित करें - तय करें कि आपको इसे आगे संसाधित करने के लिए स्वीकार करना चाहिए या उपयोगकर्ता को यह अस्वीकार्य है। लेकिन जब तक यह PHP भूमि छोड़ने वाला नहीं है तब तक डेटा के प्रतिनिधित्व में कोई परिवर्तन लागू न करें।

बहुत समय पहले किसी ने एक आकार का आविष्कार करने की कोशिश की थी ताकि डेटा से बचने के लिए सभी तंत्र फिट हो जाएं और हम " magic_quotes " के साथ समाप्त हो गए थे, जो सभी आउटपुट लक्ष्यों के लिए डेटा से ठीक से बच नहीं पाए और परिणामस्वरूप अलग-अलग इंस्टॉलेशन में काम करने के लिए अलग-अलग कोड की आवश्यकता होती है।


PHP के साथ उपयोगकर्ता इनपुट को स्वच्छ करने के लिए सबसे अच्छी मूल विधि:


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

PHP में अब नया अच्छा फ़िल्टर_इनपुट फ़ंक्शन है, उदाहरण के लिए आपको 'अंतिम ई-मेल रीगेक्स' ढूंढने से मुक्त कर दिया गया है कि अब एक अंतर्निहित FILTER_VALIDATE_EMAIL प्रकार है

मेरा स्वयं का फ़िल्टर वर्ग (दोषपूर्ण फ़ील्ड को हाइलाइट करने के लिए जावास्क्रिप्ट का उपयोग करता है) या तो अजाक्स अनुरोध या सामान्य फॉर्म पोस्ट द्वारा शुरू किया जा सकता है। (नीचे उदाहरण देखें)

/**
 *  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('[email protected]', '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;
    }       



}

बेशक, ध्यान रखें कि आप किस प्रकार के डीबी का उपयोग कर रहे हैं इस पर निर्भर करते हुए आपको अपनी एसक्यूएल क्वेरी से बचने की ज़रूरत है (mysql_real_escape_string () उदाहरण के लिए एक एसक्यूएल सर्वर के लिए बेकार है)। आप शायद इसे अपने उचित अनुप्रयोग परत पर एक ओआरएम की तरह स्वचालित रूप से संभालना चाहते हैं। साथ ही, जैसा ऊपर बताया गया है: HTML को आउटपुट करने के लिए अन्य php समर्पित कार्यों जैसे htmlspecialchars का उपयोग करें;)

वास्तव में छीनने वाले वर्गों और / या टैग के साथ HTML इनपुट की अनुमति देने के लिए समर्पित xss सत्यापन पैकेजों में से एक पर निर्भर करता है। PARSE HTML पर अपने स्वयं के पंजीकरण लिखो मत!


इनपुट को स्वच्छ करने और डेटा से बचने में गलतियों से बचने का सबसे आसान तरीका Symfony , Nette इत्यादि जैसे PHP ढांचे का उपयोग करना या उस ढांचे का हिस्सा (टेम्पलेटिंग इंजन, डेटाबेस लेयर, ओआरएम) का उपयोग करना है।

Twig या लेटे जैसे टेम्पलेटिंग इंजन में डिफॉल्ट रूप से आउटपुट हो रहा है - अगर आप संदर्भ (एचटीएमएल या वेब पेज के जावास्क्रिप्ट भाग) के आधार पर अपने आउटपुट से ठीक से बच गए हैं तो आपको मैन्युअल रूप से हल करने की ज़रूरत नहीं है।

फ्रेमवर्क स्वचालित रूप से इनपुट को स्वच्छ कर रहा है और आपको सीधे $ _POST, $ _GET या $ _SESSION चर का उपयोग नहीं करना चाहिए, लेकिन रूटिंग, सत्र हैंडलिंग इत्यादि जैसे तंत्र के माध्यम से।

और डेटाबेस (मॉडल) परत के लिए ओआरएम फ्रेमवर्क जैसे नेटटे डाटाबेस जैसे पीडीओ के आसपास सिद्धांत या रैपर हैं।

आप यहां इसके बारे में अधिक पढ़ सकते हैं - एक सॉफ्टवेयर ढांचा क्या है?


इनपुट डेटा को sanitizing द्वारा एसक्यूएल इंजेक्शन को रोकने की कोशिश मत करो।

इसके बजाय, अपने SQL कोड बनाने में डेटा का उपयोग करने की अनुमति न दें । तैयार वक्तव्य का उपयोग करें (यानी टेम्पलेट क्वेरी में पैरामीटर का उपयोग करना) जो बाध्य चर का उपयोग करता है। एसक्यूएल इंजेक्शन के खिलाफ गारंटी देने का यही एकमात्र तरीका है।

एसक्यूएल इंजेक्शन को रोकने के बारे में अधिक जानकारी के लिए कृपया मेरी वेबसाइट http://bobby-tables.com/ देखें।


एक्सएसएस मुद्दे को हल करने के लिए, एचटीएमएल शोधक पर एक नज़र डालें। यह काफी विन्यास योग्य है और इसका एक सभ्य ट्रैक रिकॉर्ड है।

एसक्यूएल इंजेक्शन हमलों के लिए, सुनिश्चित करें कि आप उपयोगकर्ता इनपुट की जांच करें, और उसके बाद इसे चलाएं mysql_real_escape_string ()। फ़ंक्शन सभी इंजेक्शन हमलों को हराने नहीं देगा, इसलिए, यह महत्वपूर्ण है कि आप इसे अपनी क्वेरी स्ट्रिंग में डंप करने से पहले डेटा जांचें।

तैयार बयान का उपयोग करना एक बेहतर समाधान है। पीडीओ लाइब्रेरी और माइस्क्ली एक्सटेंशन इन का समर्थन करते हैं।


कोई पकड़ समारोह नहीं है, क्योंकि संबोधित करने के लिए कई चिंताओं हैं।

  1. एसक्यूएल इंजेक्शन - आज, आम तौर पर, प्रत्येक PHP प्रोजेक्ट को PHP डेटा ऑब्जेक्ट्स (पीडीओ) के माध्यम से एक सर्वोत्तम अभ्यास के रूप में तैयार बयानों का उपयोग करना चाहिए, एक भटक भाव से एक त्रुटि को रोकने के साथ-साथ इंजेक्शन के खिलाफ एक पूर्ण-विशेषीकृत समाधान । यह आपके डेटाबेस तक पहुंचने का सबसे लचीला और सुरक्षित तरीका भी है।

    पीडीओ के बारे में जानने के लिए आपको जो कुछ भी चाहिए, उसके लिए पीडीओ ट्यूटोरियल देखें (केवल उचित) पीडीओ ट्यूटोरियल । (विषय पर इस महान संसाधन के लिए, शीर्ष SO योगदानकर्ता, @YourCommonSense के लिए ईमानदारी से धन्यवाद।)

  2. एक्सएसएस - रास्ते में डेटा को स्वच्छ करें ...

    • एचटीएमएल शोधक काफी समय से रहा है और अभी भी सक्रिय रूप से अपडेट किया गया है। आप इसे दुर्भावनापूर्ण इनपुट को स्वच्छ करने के लिए उपयोग कर सकते हैं, जबकि टैग की उदार और कॉन्फ़िगर करने योग्य श्वेतसूची की अनुमति दे रहे हैं। कई WYSIWYG संपादकों के साथ बहुत अच्छा काम करता है, लेकिन कुछ उपयोग मामलों के लिए यह भारी हो सकता है।

    • अन्य मामलों में, जहां हम HTML / जावास्क्रिप्ट को बिल्कुल स्वीकार नहीं करना चाहते हैं, मुझे यह सरल कार्य उपयोगी पाया गया है (और एक्सएसएस के खिलाफ कई ऑडिट पास कर चुके हैं):

      /* 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. एक्सएसएस - रास्ते पर डेटा को स्वच्छ करें ... जब तक कि आप अपने डेटाबेस में जोड़ने से पहले डेटा को उचित रूप से संचरित नहीं करते हैं, आपको इसे अपने उपयोगकर्ता को प्रदर्शित करने से पहले इसे स्वच्छ करने की आवश्यकता होगी, हम इन उपयोगी PHP फ़ंक्शंस का लाभ उठा सकते हैं:

    • जब आप उपयोगकर्ता द्वारा आपूर्ति किए गए मान प्रदर्शित करने के लिए echo या print कहते हैं, तो htmlspecialchars उपयोग करें जब तक कि डेटा को सुरक्षित रूप से सुरक्षित नहीं किया गया हो और HTML को प्रदर्शित करने की अनुमति दी जाए।
    • json_encode PHP से जावास्क्रिप्ट तक उपयोगकर्ता द्वारा प्रदत्त मान प्रदान करने का एक सुरक्षित तरीका है
  4. क्या आप exec() या system() फ़ंक्शंस, या backtick ऑपरेटर का उपयोग कर बाहरी खोल कमांड कहते हैं? यदि ऐसा है, तो SQL इंजेक्शन और एक्सएसएस के अतिरिक्त आपको पता करने के लिए एक अतिरिक्त चिंता हो सकती है, उपयोगकर्ता आपके सर्वर पर दुर्भावनापूर्ण आदेश चला रहे हैं । अगर आप पूरे आदेश से बचना चाहते हैं या अलग-अलग तर्कों से बचने के लिए बच escapeshellarg चाहते हैं तो आपको escapeshellcmd का उपयोग करने की आवश्यकता है।


नहीं। आप बिना किसी संदर्भ के डेटा को सामान्य रूप से फ़िल्टर नहीं कर सकते हैं। कभी-कभी आप इनपुट के रूप में एक SQL क्वेरी लेना चाहते हैं और कभी-कभी आप HTML को इनपुट के रूप में लेना चाहते हैं।

आपको श्वेतसूची पर इनपुट फ़िल्टर करने की आवश्यकता है - सुनिश्चित करें कि डेटा आपके द्वारा अपेक्षित चीज़ों के कुछ विनिर्देशों से मेल खाता है। इसके बाद आप इसे इस्तेमाल करने से पहले इसे बचने की जरूरत है, जिस संदर्भ में आप इसका उपयोग कर रहे हैं उसके आधार पर।

एसक्यूएल के लिए डेटा से बचने की प्रक्रिया - एसक्यूएल इंजेक्शन को रोकने के लिए - एक्सएसएस को रोकने के लिए (एक्स) एचटीएमएल के डेटा से बचने की प्रक्रिया से बहुत अलग है।


फ़िल्टर एक्सटेंशन ( howto-link , manual ) है, जो सभी जीपीसी चर के साथ बहुत अच्छी तरह से काम करता है। यह एक जादू-ऐसा नहीं है-सब कुछ हालांकि, आपको अभी भी इसका उपयोग करना होगा।


यदि आप PostgreSQL का उपयोग कर रहे हैं, तो PHP से इनपुट pg_escape_string () से बच सकता है

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

प्रलेखन से ( http://php.net/manual/es/function.pg-escape-string.php ):

pg_escape_string () डेटाबेस से पूछताछ के लिए एक स्ट्रिंग से बच निकलता है। यह उद्धरण के बिना PostgreSQL प्रारूप में एक बच निकला स्ट्रिंग देता है।


यह एक आम गलतफहमी है कि उपयोगकर्ता इनपुट फ़िल्टर किया जा सकता है। PHP में भी एक (अब बहिष्कृत) "फीचर" है, जिसे जादू-उद्धरण कहा जाता है, जो इस विचार पर बनाता है। यह बकवास है। फ़िल्टरिंग के बारे में भूल जाओ (या सफाई, या जो लोग इसे कहते हैं)।

समस्याओं से बचने के लिए आपको क्या करना चाहिए, यह काफी सरल है: जब भी आप विदेशी कोड के भीतर एक स्ट्रिंग एम्बेड करते हैं, तो आपको उस भाषा के नियमों के अनुसार इसे बचाना होगा। उदाहरण के लिए, यदि आप MySQL को लक्षित करने वाले कुछ SQL में स्ट्रिंग एम्बेड करते हैं, तो आपको इस उद्देश्य ( mysqli_real_escape_string ) के लिए MySQL के फ़ंक्शन के साथ स्ट्रिंग से बचना होगा। (या, डेटाबेस के मामले में, तैयार वक्तव्य का उपयोग करना एक बेहतर दृष्टिकोण है, जब संभव हो)

एक और उदाहरण HTML है: यदि आप HTML मार्कअप के भीतर तार एम्बेड करते हैं, तो आपको इसे htmlspecialchars से htmlspecialchars । इसका मतलब है कि प्रत्येक एकल echo या print कथन htmlspecialchars उपयोग करना चाहिए।

एक तीसरा उदाहरण शेल कमांड हो सकता है: यदि आप बाहरी कमांड में स्ट्रिंग्स (जैसे तर्क) को एम्बेड करने जा रहे हैं, और उन्हें exec साथ कॉल करें, तो आपको escapeshellcmd और escapeshellarg उपयोग करना होगा।

इत्यादि इत्यादि ...

एकमात्र ऐसा मामला जहां आपको सक्रिय रूप से डेटा फ़िल्टर करने की आवश्यकता है, यह है कि यदि आप प्रीफॉर्मेटेड इनपुट स्वीकार कर रहे हैं। उदाहरण के लिए। यदि आप अपने उपयोगकर्ताओं को HTML मार्कअप पोस्ट करने देते हैं, तो आप साइट पर प्रदर्शित करने की योजना बना रहे हैं। हालांकि, आपको हर कीमत पर इससे बचने के लिए बुद्धिमान होना चाहिए, इससे कोई फर्क नहीं पड़ता कि आप इसे कितनी अच्छी तरह फ़िल्टर करते हैं, यह हमेशा एक संभावित सुरक्षा छेद होगा।





user-input