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




security xss (14)

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

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

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

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


एक चाल जो विशिष्ट परिस्थिति में मदद कर सकती है जहां आपके पास /mypage?id=53 जैसे पृष्ठ हैं और आप WHERE क्लॉज में आईडी का उपयोग यह सुनिश्चित करने के लिए है कि आईडी निश्चित रूप से एक पूर्णांक है, जैसे:

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

लेकिन निश्चित रूप से केवल एक विशिष्ट हमले में कटौती, तो अन्य सभी उत्तरों को पढ़ें। (और हाँ मुझे पता है कि उपरोक्त कोड बहुत अच्छा नहीं है, लेकिन यह विशिष्ट रक्षा दिखाता है।)


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

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

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

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

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

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


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 के साथ उपयोगकर्ता इनपुट को स्वच्छ करने के लिए सबसे अच्छी मूल विधि:


    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 पर अपने स्वयं के पंजीकरण लिखो मत!


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

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

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


आप यहां क्या वर्णन कर रहे हैं दो अलग-अलग मुद्दे हैं:

  1. उपयोगकर्ता इनपुट डेटा को स्वच्छ करना / फ़िल्टर करना।
  2. उत्पादन से बाहर निकलना

1) उपयोगकर्ता इनपुट हमेशा बुरा माना जाना चाहिए।

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

2) यह एक बड़ा विषय है, और यह आउटपुट होने वाले डेटा के संदर्भ पर निर्भर करता है। एचटीएमएल के लिए वहाँ एचटीएमएलपुर्देशक जैसे समाधान हैं। अंगूठे के नियम के रूप में, हमेशा आप जो भी उत्पादन करते हैं उससे बचें।

दोनों मुद्दे एक ही पोस्ट में जाने के लिए बहुत बड़े हैं, लेकिन बहुत सारी पोस्ट हैं जो अधिक विस्तार से जाती हैं:

तरीके PHP आउटपुट

सुरक्षित PHP आउटपुट


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

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

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

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

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


बस आउटपुट से बचने के विषय में इसे जोड़ना चाहते थे, अगर आप अपने एचटीएमएल आउटपुट को बनाने के लिए php DOMDocument का उपयोग करते हैं तो यह स्वचालित संदर्भ में स्वचालित रूप से बच जाएगा। एक विशेषता (मान = "") और <span> का आंतरिक पाठ बराबर नहीं है। एक्सएसएस के खिलाफ सुरक्षित होने के लिए इसे पढ़ें: ओडब्ल्यूएएसपी एक्सएसएस रोकथाम धोखा शीट


नहीं वहाँ नहीं है।

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

अंगूठे के मूल नियम

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

यदि आप 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 भूमि छोड़ने वाला नहीं है तब तक डेटा के प्रतिनिधित्व में कोई परिवर्तन लागू न करें।

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


PHP 5.2 ने filter_var फ़ंक्शन पेश किया।

यह SANITIZE, वैलीडेट फिल्टर का एक बड़ा सौदा का समर्थन करता है।

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





user-input