Existe uma função catchall em algum lugar que funcione bem para higienizar a entrada do usuário para injeção de SQL e ataques XSS, enquanto ainda permite certos tipos de tags HTML?

É um equívoco comum que a entrada do usuário possa ser filtrada. O PHP ainda possui um "recurso" (agora obsoleto), chamado magic-quotes , que se baseia nessa idéia. Não faz sentido. Esqueça a filtragem (ou limpeza, ou como as pessoas chamam).

O que você deve fazer, para evitar problemas, é bastante simples: sempre que você incorpora uma cadeia de caracteres a um código estrangeiro, deve escapar dela, de acordo com as regras desse idioma. Por exemplo, se você incorporar uma string em algum SQL direcionado ao MySQL, deverá escapar da string com a função do MySQL para essa finalidade ( mysqli_real_escape_string). (Ou, no caso de bancos de dados, usar instruções preparadas é uma abordagem melhor, quando possível.)

Outro exemplo é o HTML: se você incorporar cadeias de caracteres na marcação HTML, deverá escapar dela htmlspecialchars. Isso significa que cada declaração echoou printdeclaração deve ser usada htmlspecialchars.

Um terceiro exemplo pode ser os comandos do shell: se você deseja incorporar seqüências de caracteres (como argumentos) a comandos externos e chamá-las com exec, deve usar escapeshellcmde escapeshellarg.

E assim por diante ...

O único caso em que você precisa filtrar ativamente os dados é se você está aceitando entrada pré-formatada. Por exemplo, se você permitir que seus usuários publiquem a marcação HTML, planeja exibir no site. No entanto, é prudente evitar isso a todo custo, pois, independentemente de quão bem você o filtre, sempre será uma falha de segurança em potencial.

Não tente impedir a injeção de SQL limpando os dados de entrada.

Em vez disso, não permita que dados sejam usados ​​na criação do seu código SQL . Use Instruções Preparadas (ou seja, usando parâmetros em uma consulta de modelo) que usa variáveis ​​ligadas. É a única maneira de garantir a injeção de SQL.

Por favor, consulte o meu site http://bobby-tables.com/ para obter mais informações sobre como evitar a injeção de SQL.

Não. Você não pode filtrar dados genericamente sem qualquer contexto para o que serve. Às vezes, você deseja aceitar uma consulta SQL como entrada e, às vezes, deseja aceitar HTML como entrada.

Você precisa filtrar a entrada em uma lista de permissões - verifique se os dados correspondem a alguma especificação do que você espera. Então você precisa escapar antes de usá-lo, dependendo do contexto em que o está usando.

O processo de escape de dados para SQL - para impedir a injeção de SQL - é muito diferente do processo de escape de dados para (X) HTML, para impedir o XSS.

O PHP tem agora as novas funções agradáveis ​​filter_input, que por exemplo o libertam de encontrar 'o melhor regex de e-mail' agora que existe um tipo FILTER_VALIDATE_EMAIL embutido

Minha própria classe de filtro (usa JavaScript para destacar campos defeituosos) pode ser iniciada por uma solicitação ajax ou por uma postagem de formulário normal. (veja o exemplo abaixo)

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



}

Obviamente, lembre-se de que você precisa executar sua consulta sql também, dependendo do tipo de banco de dados que você está usando (mysql_real_escape_string () é inútil para um servidor sql, por exemplo). Você provavelmente deseja lidar com isso automaticamente em sua camada de aplicativo apropriada, como um ORM. Além disso, como mencionado acima: para enviar para html use as outras funções dedicadas em php como htmlspecialchars;)

Para permitir realmente a entrada HTML com classes e / ou tags despojadas, dependa de um dos pacotes de validação xss dedicados. NÃO ESCREVA SEUS PRÓPRIOS REGEXES PARA COMPARTILHAR HTML!

Não, não há.

Em primeiro lugar, a injeção SQL é um problema de filtragem de entrada e o XSS é uma saída que foge da saída - portanto, você nem executaria essas duas operações ao mesmo tempo no ciclo de vida do código.

Regras básicas básicas

• Para consulta SQL, vincule parâmetros (como no PDO) ou use uma função de escape nativa do driver para variáveis ​​de consulta (como mysql_real_escape_string())
• Use strip_tags()para filtrar HTML indesejado
• Escape de todas as outras saídas com htmlspecialchars()e esteja atento aos segundo e terceiro parâmetros aqui.

Para resolver o problema do XSS, consulte o HTML Purifier . É bastante configurável e tem um histórico decente.

Quanto aos ataques de injeção SQL, verifique a entrada do usuário e execute-a através de mysql_real_escape_string (). Porém, a função não derrota todos os ataques de injeção, portanto, é importante que você verifique os dados antes de jogá-los na cadeia de caracteres da consulta.

Uma solução melhor é usar instruções preparadas. A biblioteca PDO e a extensão mysqli suportam isso.

O PHP 5.2 introduziu o filter_var função .

Ele suporta uma grande quantidade de filtros SANITIZE, VALIDATE.

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

Um truque que pode ajudar na circunstância específica em que você tem uma página /mypage?id=53e usa o id em uma cláusula WHERE é garantir que o id definitivamente seja um número inteiro, assim:

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

Mas é claro que isso apenas interrompe um ataque específico, portanto, leia todas as outras respostas. (E sim, eu sei que o código acima não é ótimo, mas mostra a defesa específica.)

Métodos para higienizar a entrada do usuário com PHP:

• Use versões modernas do MySQL e PHP.

• Defina charset explicitamente:

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

    ^manual

  • $ pdo = novo PDO ('mysql: host = localhost; dbname = testdb; charset = UTF8', $ usuário, $ senha);

    ^manual

  • $ pdo-> exec ("definir nomes utf8");

    ^manual

  • $ pdo = nova DOP (
    "mysql: host = $ host; dbname = $ db", $ user, $ pass, 
    matriz (
    DOP :: ATTR_ERRMODE => DOP :: ERRMODE_EXCEPTION,
    DOP :: MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"
    )
    );

    ^manual

  • mysql_set_charset ('utf8')

    ^{[obsoleto no PHP 5.5.0, removido no PHP 7.0.0].}

• Use conjuntos de caracteres seguros:

  • Selecione utf8, latin1, ascii .., não use conjuntos de caracteres vulneráveis ​​big5, cp932, gb2312, gbk, sjis.

• Use a função espacializada:

  • Instruções preparadas para o MySQLi:
    

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

  • PDO :: quote () - coloca aspas ao redor da string de entrada (se necessário) e escapa caracteres especiais dentro da string de entrada, usando um estilo de aspas apropriado ao driver subjacente:
    

    $ pdo = novo PDO ('mysql: host = localhost; dbname = testdb; charset = UTF8', $ usuário, $ senha); conjunto explícito do conjunto de caracteres
     $ pdo-> setAttribute (PDO :: ATTR_EMULATE_PREPARES, false); desabilite a emulação de instruções preparadas para evitar fallback para emulações que o MySQL não pode preparar de forma nativa (para impedir a injeção)
     $ var = $ pdo-> quote ("'OR 1 = 1 / *"); não apenas escapa ao literal, mas também o aspas (em caracteres de aspas simples)
    $ stmt = $ pdo-> query ("SELECT * FROM teste WHERE nome = $ var LIMIT 1");
    

  • Declarações Preparadas para DOP : As instruções preparadas contra o MySQLi suportam mais drivers de banco de dados e parâmetros nomeados:
    

    $ pdo = novo PDO ('mysql: host = localhost; dbname = testdb; charset = UTF8', $ usuário, $ senha); conjunto explícito do conjunto de caracteres
     $ pdo-> setAttribute (PDO :: ATTR_EMULATE_PREPARES, false); desabilite a emulação de instruções preparadas para evitar fallback para emulações de instruções que o MySQL não pode preparar nativamente (para impedir a injeção)
    $ stmt = $ pdo-> prepare ('SELECT * FROM teste WHERE nome =? LIMIT 1');
    $ stmt-> execute (["'OR 1 = 1 / *"]);

  • mysql_real_escape_string ^{[obsoleto no PHP 5.5.0, removido no PHP 7.0.0].}
  • mysqli_real_escape_string Escapa caracteres especiais em uma string para uso em uma instrução SQL, levando em consideração o conjunto de caracteres atual da conexão. Mas recomendado usar instruções preparadas porque elas não são simplesmente seqüências de escape, uma instrução apresenta um plano de execução de consulta completo, incluindo quais tabelas e índices ela usaria, é uma maneira otimizada.
  • Use aspas simples ('') em torno de suas variáveis ​​na sua consulta.

• Verifique se a variável contém o que você está esperando:

  • Se você está esperando um número inteiro, use:

    ctype_digit - Verifique se há caracteres numéricos; 
    $ valor = (int) $ valor; 
    $ valor = intval (valor $); 
    $ var = filter_var ('0755', FILTER_VALIDATE_INT, $ opções);

  • Para Strings use:

    is_string () - Descubra se o tipo de uma variável é string

    
    Use a Função de Filtro filter_var () - filtra uma variável com um filtro especificado:
    

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

    filtros mais predefinidos
    
  • filter_input () - obtém uma variável externa específica por nome e, opcionalmente, a filtra:

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

  • preg_match () - Executa uma correspondência de expressão regular;
    
  • Escreva sua própria função de validação.

O que você está descrevendo aqui são dois problemas separados:

1. Higienização / filtragem de dados de entrada do usuário.
2. Saída de escape.

1) A entrada do usuário sempre deve ser considerada ruim.

Usar instruções preparadas ou / e filtrar com mysql_real_escape_string é definitivamente uma obrigação. O PHP também possui filter_input, o que é um bom ponto de partida.

2) Esse é um tópico amplo e depende do contexto dos dados que estão sendo impressos. Para HTML, existem soluções como o htmlpurifier por aí. Como regra geral, sempre escape qualquer coisa que você produz.

Ambos os problemas são grandes demais para serem analisados ​​em uma única postagem, mas há muitas que entram em mais detalhes:

Métodos Saída PHP

Saída PHP mais segura

Se você estiver usando o PostgreSQL, a entrada do PHP pode ser escapada com pg_escape_string ()

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

Na documentação ( http://php.net/manual/es/function.pg-escape-string.php ):

pg_escape_string () escapa uma string para consultar o banco de dados. Retorna uma string de escape no formato PostgreSQL sem aspas.

Não existe uma função abrangente, porque há várias preocupações a serem abordadas.

1. Injeção de SQL - Hoje, geralmente, todo projeto PHP deve usar instruções preparadas por meio de PHP Data Objects (PDO) como uma prática recomendada, evitando erros de aspas perdidas e uma solução completa contra injeção. . É também a maneira mais flexível e segura de acessar seu banco de dados.

   Confira o tutorial do PDO (o único apropriado) para praticamente tudo o que você precisa saber sobre o DOP. (Agradecimentos sinceros ao principal colaborador do SO, @YourCommonSense, por este excelente recurso sobre o assunto.)

2. XSS - higienizar dados a caminho de ...

   • O Purificador HTML já existe há muito tempo e ainda é atualizado ativamente. Você pode usá-lo para limpar informações maliciosas, enquanto ainda permite uma lista de permissões generosa e configurável. Funciona muito bem com muitos editores WYSIWYG, mas pode ser pesado para alguns casos de uso.

   • Em outros casos, onde não queremos aceitar HTML / Javascript, achei essa função simples útil (e passou por várias auditorias no 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 - higienize dados na saída ... a menos que você garanta que os dados foram higienizados adequadamente antes de adicioná-los ao seu banco de dados, será necessário higienizá-los antes de exibi-los para o usuário, podemos aproveitar essas funções úteis do PHP:

   • Ao ligar echoou printexibir valores fornecidos pelo usuário, use htmlspecialchars, a menos que os dados tenham sido higienizados adequadamente e que sejam permitidos exibir HTML.
   • json_encode é uma maneira segura de fornecer valores fornecidos pelo usuário, de PHP a Javascript

4. Você chama comandos shell externos usando exec()ou system()functions ou para o backtickoperador? Nesse caso, além do SQL Injection & XSS, você pode ter uma preocupação adicional a tratar, os usuários executando comandos maliciosos no seu servidor . Você precisa usar escapeshellcmdse quiser escapar de todo o comando OU escapeshellargpara escapar de argumentos individuais.

A maneira mais fácil de evitar erros na limpeza de dados de entrada e escape é usar a estrutura PHP como Symfony , Nette etc. ou parte dessa estrutura (mecanismo de modelagem, camada de banco de dados, ORM).

Mecanismos de modelagem como Twig ou Latte têm saída com escape por padrão - você não precisa resolver manualmente se tiver escapado adequadamente da saída, dependendo do contexto (parte HTML ou Javascript da página da web).

O Framework limpa automaticamente as entradas e você não deve usar as variáveis ​​$ _POST, $ _GET ou $ _SESSION diretamente, mas através de mecanismos como roteamento, manipulação de sessões etc.

E para a camada de banco de dados (modelo), existem estruturas ORM como Doctrine ou wrappers em torno do PDO como Nette Database.

Você pode ler mais sobre isso aqui - O que é uma estrutura de software?

Só queria acrescentar que, no assunto de saída de escape, se você usar o php DOMDocument para fazer sua saída de html, ela escapará automaticamente no contexto certo. Um atributo (value = "") e o texto interno de um <span> não são iguais. Para estar seguro contra o XSS, leia o seguinte: Folha de dicas de prevenção do OWASP XSS

Você nunca limpa a entrada.

Você sempre limpa a saída.

As transformações que você aplica aos dados para torná-lo seguro para inclusão em uma instrução SQL são completamente diferentes daquelas que você solicita para inclusão em HTML são completamente diferentes daquelas que você solicita para inclusão em Javascript são completamente diferentes daquelas que solicita para inclusão em LDIF. completamente diferentes daqueles que você aplica à inclusão em CSS são completamente diferentes daqueles que você aplica à inclusão em um E-mail ....

Por todos os meios, valide a entrada - decida se você deve aceitá-la para processamento adicional ou se é inaceitável para o usuário. Mas não aplique nenhuma alteração na representação dos dados até que esteja prestes a sair do PHP.

Há muito tempo, alguém tentou inventar um mecanismo único para todos os dados de escape e acabamos com " magic_quotes " que não escapavam adequadamente aos dados de todos os destinos de saída e resultavam em instalações diferentes, exigindo código diferente para funcionar.

Nunca confie nos dados do usuário.

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

A trim()função remove espaços em branco e outros caracteres predefinidos dos dois lados de uma sequência.

A stripslashes()função remove barras invertidas

A htmlspecialchars()função converte alguns caracteres predefinidos em entidades HTML.

Os caracteres predefinidos são:

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

Existe a extensão do filtro ( howto-link , manual ), que funciona muito bem com todas as variáveis ​​GPC. Não é algo mágico, você ainda precisará usá-lo.