Nie próbuj zapobiegać iniekcji SQL poprzez dezynfekcję danych wejściowych.

Zamiast tego, nie zezwalaj na wykorzystanie danych do tworzenia kodu SQL . Użyj gotowych instrukcji (tzn. używając parametrów w zapytaniu szablonu), które używają powiązanych zmiennych. Jest to jedyny sposób na zabezpieczenie przed SQL injection.

Zapraszam na moją stronę http://bobby-tables.com/ aby dowiedzieć się więcej o zapobieganiu SQL injection.

Nie. Nie można ogólnie filtrować danych bez kontekstu tego, do czego służą. Czasami chcesz wziąć zapytanie SQL jako wejście, a czasami chcesz wziąć HTML jako wejście.

Musisz filtrować dane wejściowe na białej liście-upewnij się, że dane pasują do specyfikacji tego, czego oczekujesz. Następnie musisz z niego uciec, zanim go użyjesz, W zależności od kontekstu, w którym go używasz.

Proces ucieczki danych dla SQL-aby zapobiec SQL injection-jest bardzo różny z procesu ucieczki danych dla (X)HTML, aby zapobiec XSS.

PHP ma teraz nowe funkcje nice filter_input, które na przykład uwalniają cię od znalezienia 'ostatecznego regex e-mail' teraz, gdy istnieje wbudowany typ FILTER_VALIDATE_EMAIL

Moja własna Klasa filtrów (używa JavaScript do podkreślania wadliwych pól) może być inicjowana przez żądanie ajax lub zwykły post formularza. (patrz przykład poniżej)

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



}

Oczywiście pamiętaj, że musisz również wykonać swoje zapytanie sql escaping w zależności od tego, jakiego typu db używasz (mysql_real_escape_string () jest bezużyteczny na przykład dla serwera sql). Prawdopodobnie chcesz obsłużyć to automatycznie na odpowiedniej warstwie aplikacji, takiej jak ORM. Ponadto, jak wspomniano powyżej: do wyprowadzania do html użyj innych dedykowanych funkcji php, takich jak htmlspecialchars;)

Aby naprawdę umożliwić wprowadzanie HTML z takimi klasami i/lub znacznikami zależy od jednego z dedykowanych pakietów walidacji XSS. NIE PISZ WŁASNYCH WYRAŻEŃ REGULARNYCH DO ANALIZY HTML!

Nie, Nie ma.

Po pierwsze, SQL injection jest problemem filtrowania danych wejściowych, a XSS jest wyjściem uciekającym - więc nie wykonywałbyś tych dwóch operacji w tym samym czasie w cyklu życia kodu.

Podstawowe zasady thumb

W przypadku zapytań SQL, parametry bind (jak w przypadku PDO) lub użyj natywnej funkcji ucieczki sterownika dla zmiennych zapytań (takich jak mysql_real_escape_string())
• Użyj strip_tags() aby odfiltrować niechciany HTML
• Escape all other output with htmlspecialchars() and be pamiętając o 2. i 3. parametrach tutaj.

Aby rozwiązać problem z XSS, spójrz na HTML Purifier . Jest dość konfigurowalny i ma przyzwoite osiągnięcia.

Jeśli chodzi o ataki SQL injection, sprawdź dane wejściowe użytkownika, a następnie uruchom je za pomocą mysql_real_escape_string (). Funkcja nie pokona jednak wszystkich ataków iniekcyjnych, dlatego ważne jest, aby sprawdzić dane przed wrzuceniem ich do ciągu zapytania.

Lepszym rozwiązaniem jest użycie gotowych instrukcji. Biblioteka PDO oraz rozszerzenie mysqli obsługuje te.

PHP 5.2 wprowadził funkcję filter_var.

Obsługuje wiele dezynfekcji, walidacji filtrów.

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

Jedna sztuczka, która może pomóc w konkretnej sytuacji, gdy masz stronę jak {[1] } i używasz id w klauzuli WHERE jest zapewnienie, że id zdecydowanie jest liczbą całkowitą, jak TAK:

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

Ale oczywiście to eliminuje tylko jeden konkretny atak, więc przeczytaj wszystkie pozostałe odpowiedzi. (I tak Wiem, że powyższy kod nie jest świetny, ale pokazuje konkretną obronę.)

Metody dezynfekcji wejścia użytkownika za pomocą PHP:

• Korzystaj z nowoczesnych wersji MySQL i PHP.

• Ustaw znak jawnie:

  • $mysqli->set_charset("utf8");

    ^Instrukcja

  • $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $user, $password);

    ^Instrukcja

  • $pdo->exec("set names utf8");

    ^Instrukcja

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

    ^Instrukcja

  • mysql_set_charset('utf8')

    ^{[deprecated in PHP 5.5.0, removed in PHP 7.0.0].}

• Użyj bezpiecznych zestawów znaków:

  • Wybierz utf8, latin1, ascii.., nie używaj podatnych znaków big5, cp932, GB2312, gbk, sjis.

• Użyj funkcji spatialized:

  • MySQLi przygotowało Oświadczenia:
    

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

  • PDO:: quote() - umieszcza cudzysłowy wokół łańcucha wejściowego (jeśli jest to wymagane) i usuwa znaki specjalne wewnątrz łańcucha wejściowego, używając stylu cytowania odpowiedni do podstawowego sterownika:
    

    $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 prepared statements obsługuje więcej sterowników bazy danych i nazwanych parametrów:
    

    $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 ^{[deprecated in PHP 5.5.0, removed in PHP 7.0.0].}
  • mysqli_real_escape_string usuwa znaki specjalne w ciągu znaków do użycia w instrukcji SQL, biorąc pod uwagę bieżący zestaw znaków połączenia. Zaleca się jednak używanie instrukcji Prepared, ponieważ nie są one po prostu znakami ucieczki, instrukcja zawiera kompletny plan wykonywania zapytań, w tym tabele i indeksy, których używa, jest to zoptymalizowany sposób.
  • użyj pojedynczych cudzysłowów (' ') wokół zmiennych w zapytaniu.

• Sprawdź, czy zmienna zawiera to, czego oczekujesz:

  • jeśli oczekujesz liczby całkowitej, użyj:

    ctype_digit — Check for numeric character(s);
    $value = (int) $value;
    $value = intval($value);
    $var = filter_var('0755', FILTER_VALIDATE_INT, $options);

  • Dla Strun użycie:

    is_string() — Find whether the type of a variable is string

    
    użyj funkcja filtra filter_var () - filtruje zmienną o podanym filtrze:
    

    $email = filter_var($email, FILTER_SANITIZE_EMAIL);
    $newstr = filter_var($str, FILTER_SANITIZE_STRING);

    więcej predefiniowanych filtrów
    
  • filter_input () - pobiera określoną zewnętrzną zmienną po nazwie i opcjonalnie ją filtruje:

    $search_html = filter_input(INPUT_GET, 'search', FILTER_SANITIZE_SPECIAL_CHARS);

  • preg_match () - wykonaj dopasowanie wyrażenia regularnego;
    
  • Napisz własną funkcję walidacji.

To co tu opisujesz to dwie osobne kwestie:

1. dezynfekcja / filtrowanie danych wejściowych użytkownika.
2. Wyjście wyjściowe.

1) należy zawsze zakładać, że dane wejściowe użytkownika są złe.

Używanie gotowych instrukcji lub / i filtrowanie za pomocą mysql_real_escape_string jest zdecydowanie koniecznością. PHP ma również wbudowany filter_input, który jest dobrym miejscem do rozpoczęcia.

2) jest to duży temat i zależy od kontekstu danych wyjściowych. Dla HTML tam są rozwiązania takie jak htmlpurifier tam. z reguły zawsze unikaj wszystkiego, co wydajesz.

Oba problemy są zbyt duże, aby przejść w jednym poście, ale jest wiele postów, które idą w szczegółach:

Metody PHP output

Bezpieczniejsze wyjście PHP

Nie ma funkcji catchall, ponieważ istnieje wiele problemów do rozwiązania.

1. SQL Injection - obecnie, ogólnie rzecz biorąc, każdy projekt PHP powinien używać przygotowanych instrukcji za pomocą PHP Data Objects (PDO) jako najlepszej praktyki, zapobiegając błędowi z zabłąkanego cytatu, a także w pełni funkcjonalnego rozwiązania przeciwko injection. Jest to również najbardziej elastyczny i bezpieczny sposób dostępu do bazy danych.

   Zobacz (jedyny proper) PDO tutorial za prawie wszystko, co musisz wiedzieć o PDO. (Szczere podziękowania dla top SO contributor, @ YourCommonSense, za ten wielki zasób na ten temat.)

2. XSS-dezynfekcja danych w drodze...

   • HTML Purifier istnieje już od dawna i jest nadal aktywnie aktualizowany. Możesz go użyć do dezynfekcji złośliwych danych wejściowych, jednocześnie zezwalając na dużą i konfigurowalną białą listę tagów. Działa świetnie z wieloma edytorami WYSIWYG, ale może być ciężki dla niektórych przypadków użycia.

   • W innych przypadkach, gdzie w ogóle nie chcemy akceptować HTML/Javascript, uznałem tę prostą funkcję za przydatną (i przeszedł wiele audytów przeciwko XSS):

     /* 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-odkażanie danych w drodze powrotnej... o ile nie zagwarantujesz, że dane zostały prawidłowo zdezynfekowane przed dodaniem ich do bazy danych, musisz je zdezynfekować przed wyświetlaniem to do użytkownika, możemy wykorzystać te przydatne funkcje PHP:

   • gdy wywołujesz echo lub print, aby wyświetlić wartości dostarczone przez użytkownika, użyj htmlspecialchars chyba, że dane zostały prawidłowo wyczyszczone bezpiecznie i może wyświetlać HTML.
   • json_encode jest to bezpieczny sposób na dostarczenie wartości dostarczonych przez użytkownika z PHP do Javascript

4. Czy wywołujesz zewnętrzne polecenia powłoki używając exec() lub system() funkcje, lub do backtick centrala? Jeśli tak, oprócz SQL Injection & XSS możesz mieć dodatkowy problem do adresowania, użytkowników uruchamiających złośliwe polecenia na twoim serwerze. Musisz użyć escapeshellcmd Jeśli chcesz uciec od całego dowództwa lub escapeshellarg aby uniknąć indywidualnych argumentów.

Jeśli używasz PostgreSQL, dane wejściowe z PHP mogą być przetwarzane za pomocą pg_escape_string ()

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

Z dokumentacji ( http://php.net/manual/es/function.pg-escape-string.php):

Pg_escape_string () przechowuje łańcuch znaków do odpytywania bazy danych. Zwraca unikalny ciąg znaków w formacie PostgreSQL bez cudzysłowów.

Najprostszym sposobem na uniknięcie błędów w dezynfekcji danych wejściowych i ucieczki jest użycie frameworka PHP, takiego jak Symfony, Nette itd. lub część tego frameworka(silnik szablonów, warstwa bazy danych, ORM).

Silnik szablonów, taki jakTwig lub Latte ma domyślnie włączone wyjście ucieczki - nie musisz rozwiązywać ręcznie, jeśli poprawnie uniknąłeś wyjścia w zależności od kontekstu (część HTML lub Javascript strony internetowej).

Framework automatycznie dezynfekuje wejście i nie należy używać zmiennych $_POST, $_GET lub $_SESSION bezpośrednio, ale poprzez takie mechanizmy jak routing, obsługa sesji itp.

A dla warstwy bazy danych (modelu) istnieją frameworki ORM takie jak Doctrine lub wrappery wokół PDO takie jak Nette Database.

Możesz przeczytać więcej na ten temat tutaj- co to jest Framework oprogramowania?

Chciałem tylko dodać, że jeśli używasz PHP DOMDocument do tworzenia kodu html, będzie on automatycznie uciekał w odpowiednim kontekście. Atrybut (value="") i wewnętrzny tekst nie są sobie równe. Aby być bezpiecznym przed XSS przeczytaj to: OWASP XSS Prevention Cheat Sheet

Nigdy nie dezynfekujesz wejścia.

Zawsze dezynfekujesz wyjście.

Transformaty, które aplikujesz do danych, aby zapewnić ich bezpieczeństwo w instrukcji SQL, są zupełnie inne od tych, które aplikujesz do włączenia w HTML, są zupełnie inne od tych, które aplikujesz do włączenia w Javascript, są zupełnie inne od tych, które aplikujesz do włączenia w LDIF, są zupełnie inne od tych, które aplikujesz do włączenia w CSS, są zupełnie inne od tych, które aplikujesz do włączenia w mailu....

By all means validate input - zdecyduj, czy chcesz go zaakceptować do dalszego przetwarzania, czy powiedz użytkownikowi, że jest nie do przyjęcia. Ale nie stosuj żadnych zmian w reprezentacji danych, dopóki nie opuszczą one ziemi PHP.

Dawno temu ktoś próbował wymyślić uniwersalny mechanizm do ucieczki danych i skończyło się na " magic_quotes ", który nie wydostał się poprawnie z danych dla wszystkich celów wyjściowych i skutkował inną instalacją Wymaganie innego kodu do działania.

Istnieje rozszerzenie filtra (howto-link, manual ), który działa całkiem dobrze ze wszystkimi zmiennymi GPC. Nie jest to jednak Magia-zrób-to-wszystko, nadal będziesz musiał go użyć.

Nigdy nie ufaj danym użytkownika.

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

Funkcja trim() Usuwa spacje i inne predefiniowane znaki z obu stron łańcucha.

Funkcja stripslashes() usuwa ukośniki odwrotne

Funkcja htmlspecialchars() konwertuje niektóre predefiniowane znaki na encje HTML.

Predefiniowanymi znakami są:

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