Hay un cajón de la función en algún lugar que funciona bien para la desinfección de la entrada del usuario para la inyección de SQL y ataques XSS, mientras que todavía permite que ciertos tipos de etiquetas html?

Hoy en día, para evitar la inyección sql, uso de PDO o MySQLi.
Usando PDO o MySQLi no es suficiente. Si usted construye sus instrucciones SQL con los que no son de confianza de los datos, como select * from users where name='$name', entonces no importa si usted usar PDO o MySQLi o MySQL. Usted todavía está en peligro. Usted debe utilizar las consultas parametrizadas o, si es necesario, use escapar de los mecanismos en los datos, pero que es mucho menos preferible.
Está usted insinuando que alguien utiliza PDO sin instrucciones preparadas? 🙂
Estoy diciendo que «el Uso de PDO o MySQLi» no es información suficiente para explicar a los novatos sobre cómo utilizar de forma segura. Usted y yo sabemos que las sentencias preparadas de la materia, pero no asumo que todos los que leen esta pregunta va a saber. Es por eso que he añadido las instrucciones explícitas.
Comentario de Andy es totalmente válido. Me convertí en mi sitio web de mysql PDO recientemente pensar que ahora estaba de alguna manera a salvo de los ataques de inyección. Fue sólo durante el proceso me di cuenta de que algunos de mis instrucciones sql eran todavía el uso de la entrada del usuario. Luego me fijo que el uso de declaraciones preparadas. Para un principiante, no es completamente claro que hay una distinción como muchos expertos tirar el comentario sobre el uso de PDO, pero no se especifica la necesidad de que las sentencias preparadas. El supuesto de que esto es obvio. Pero no para un novato.

OriginalEl autor Brent | 2008-09-24

18 Comentarios

  1. 1091

    Es un error común pensar que la entrada del usuario puede ser filtrada. PHP tiene incluso una (ahora en desuso) «función», se llama la magia de las cotizaciones, que se basa en esta idea. Eso es un disparate. Olvídate de filtrado (O de limpieza, o lo que sea la gente la llama).

    Lo que debe hacer, para evitar problemas, es muy simple: cada vez que se incorpora una cadena dentro de extranjeros código, debe escapar de él, de acuerdo a las reglas de ese idioma. Por ejemplo, si desea insertar una cadena de caracteres en SQL orientación de MySql, debe escapar de la cadena con MySql función para este propósito (mysqli_real_escape_string). (O, en el caso de bases de datos, utilizando las sentencias preparadas son un método mejor, cuando sea posible)

    Otro ejemplo es HTML: Si incrusta dentro de las cadenas de marcado HTML, debe escapar de ella con htmlspecialchars. Esto significa que cada uno de los echo o print instrucción debe usar htmlspecialchars.

    Un tercer ejemplo podría ser el shell de comandos: Si usted va a integrar cadenas (como argumentos) a comandos externos, y llamar a ellos con exec, entonces usted debe utilizar escapeshellcmd y escapeshellarg.

    Y así sucesivamente y así sucesivamente …

    La sólo caso de que usted necesita activamente filtro de datos, es que si usted está aceptando formato de entrada. Por ejemplo. si usted deja a sus usuarios publicar el lenguaje de marcado HTML, que se va a mostrar en el sitio. Sin embargo, se debe ser prudente para evitar esto a toda costa, ya que no importa lo bien que usted filtro, siempre será un potencial agujero de seguridad.

    «Esto significa que cada uno de los echo o print instrucción debe usar htmlspecialchars» – por supuesto, se refiere a «… la declaración de salida de entrada de usuario»; htmlspecialchars()-ifying «echo ‘Hola, mundo!’;» sería una locura 😉
    Excelente concisa respuesta! Me estremezco cuando oigo hablar de desinfección de entrada sin tener en cuenta el contexto.
    Hay un caso en el que creo que el filtrado es la solución correcta: UTF-8. Usted no quiere UTF-8 no válida secuencias de toda la aplicación (usted puede obtener diferentes de recuperación de error dependiendo de la ruta de acceso del código), y UTF-8 puede ser filtrada (o rechazado) fácilmente.
    Sí, y también puede ser útil para filtrar el control de los caracteres de nueva línea en este momento. Sin embargo, dado que la mayoría de las aplicaciones PHP no puede incluso obtener el código HTML, escapa a la derecha, sin embargo, yo no voy a empujar la extralargo UTF-8 secuencia problema (que sólo son realmente un problema en IE6 pre-Service-Pack-2 y viejas Óperas).
    no, COMO los usos especializados regexp idioma. Usted tendrá que escapar de su cadena de entrada dos veces: una vez para el regexp y una vez para la base de la cadena de codificación. Es de código dentro del código dentro del código.

    OriginalEl autor troelskn

  2. 188

    No tratar de evitar las inyecciones SQL mediante la desinfección de los datos de entrada.

    Lugar, no permiten que los datos sean utilizados en la creación de su código SQL. El uso de Declaraciones Preparadas (es decir, el uso de parámetros en una plantilla de consulta) que utiliza variables vinculadas. Es la única manera de estar garantizado contra inyección SQL.

    Por favor vea mi sitio web http://bobby-tables.com/ para obtener más información sobre la prevención de la inyección de SQL.

    O visite el documentación oficial y aprender las DOP y las declaraciones preparadas. Pequeña curva de aprendizaje, pero si usted sabe de SQL bastante bien, no tendrás problemas para adaptarse.
    Para el caso específico de la Inyección de SQL, esto es la respuesta correcta!
    Tenga en cuenta que las sentencias preparadas no agregar ningún tipo de seguridad, parametrizar consultas. Se acaba de pasar a ser muy fácil de usar juntos en PHP.
    No es la única manera garantizada. Hexagonal de la entrada y unhex en consulta evitará también. También hex ataques no son posibles si utiliza hexing derecho.
    Qué pasa si usted está introduciendo algo especializadas, como las direcciones de correo electrónico o nombres de usuario?

    OriginalEl autor Andy Lester

  3. 72

    No. Usted no puede genéricamente filtro de datos sin ningún tipo de contexto de lo que es. A veces te gustaría tener una consulta SQL como entrada y, a veces, te gustaría tomar HTML como entrada.

    Usted necesita el filtro de entrada en una lista blanca-asegurarse de que los datos coinciden con algunas especificaciones de lo que esperaba. Entonces usted necesita para escapar de ella antes de utilizar, dependiendo del contexto en el que se utiliza.

    El proceso de escapar de datos para SQL – para evitar la inyección SQL, es muy diferente del proceso de escapar de datos de (X)HTML, para evitar XSS.

    +1 «no Se puede genéricamente filtro de datos sin ningún tipo de contexto de lo que es.» Se debe repetir más a menudo.

    OriginalEl autor Daniel Papasian

  4. 46

    PHP tiene la nueva agradable filter_input funciones de ahora, que, por ejemplo, a liberar a partir de la búsqueda de ‘el último e-mail regex’ ahora que hay un built-in FILTER_VALIDATE_EMAIL tipo

    Mi propia clase de filtro (usa javascript para resaltar defectuoso campos) puede ser iniciado por cualquiera de una petición ajax o forma normal de correos. (ver el ejemplo a continuación)

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

    Por supuesto, tenga en cuenta que usted necesita para hacer su consulta sql escapar demasiado dependiendo de qué tipo de db que está utilizando (mysql_real_escape_string() es inútil para un servidor sql por ejemplo). Usted probablemente querrá manejar esto de forma automática en su correspondiente capa de aplicación como un ORM. También, como se mencionó anteriormente: para dar salida a html, utilice el otro php funciones específicas como htmlspecialchars 😉

    Para permitir realmente HTML de entrada con despojado de clases y/o etiquetas dependen uno de los dedicados xss validación de paquetes. NO ESCRIBA SUS PROPIAS EXPRESIONES REGULARES PARA ANALIZAR HTML!

    Esto parece que podría ser una útil script para validar las entradas, pero es que completo irrelevante para la pregunta.
    s/sanatize/desinfectar/g;
    s/desinfectar/asepsia/g;
    té y pastelillos ? asepsia : desinfectar

    OriginalEl autor SchizoDuckie

  5. 40

    No, no la hay.

    Primera de todas, la inyección de SQL es un filtro de entrada del problema, y XSS es una salida de escape de un modo que ni siquiera la ejecución de estas dos operaciones al mismo tiempo, en el código de ciclo de vida.

    Reglas básicas de pulgar

    • Para consulta de SQL, enlazar parámetros (como con DOP) o utilizar un controlador nativo de escapar función de las variables de consulta (como mysql_real_escape_string())
    • Uso strip_tags() para filtrar no deseados HTML
    • Escapar de todos los demás salida con htmlspecialchars() y ser conscientes de la 2ª y 3ª parámetros de aquí.
    Por lo que sólo utiliza strip_tags() o htmlspecialchars() cuando se sabe que la entrada de HTML que desea deshacerse de, o de escape, respectivamente – no uso de la misma para fines de seguridad a la derecha? También, al hacer el enlace, lo hace por cosas como Bobby Tablas? «Robert’); DROP TABLE Estudiantes;–» ¿se acaba de escapar de la cita?
    Si usted tiene los datos de usuario que va a ir en una base de datos y posteriormente ser mostrados en páginas web, no suele leer mucho más de lo que está escrito? Para mí, tiene más sentido para el filtro una vez (como entrada), antes de guardarlo, en lugar de tener que filtrar cada vez que se visualiza. Me estoy perdiendo algo o hizo un montón de gente que voto por innecesaria sobrecarga de rendimiento en el este y el aceptado la respuesta?
    La mejor respuesta para mí. Es corto y se aborda la cuestión de bien, si usted me pregunta. Es posible ataque de PHP de alguna manera a través de $_POST o $_GET con algunos de inyección o es imposible?

    OriginalEl autor Peter Bailey

  6. 21

    Para abordar el problema de XSS, echa un vistazo a HTML Purifier. Es bastante configurable y tiene un decente trayectoria.

    Como para los ataques de inyección de SQL, asegúrese de comprobar la entrada del usuario y, a continuación, ejecutarlo aunque mysql_real_escape_string(). La función no derrota a todos los ataques de inyección de código, aunque, por lo que es importante que usted compruebe los datos antes de su vertimiento en la cadena de consulta.

    La mejor solución es el uso de declaraciones preparadas. El PDO de la biblioteca y extensión mysqli apoyo de estos.

    no hay una «mejor manera» de hacer algo como desinfectante de entrada.. el Uso de alguna librería, html purifier es bueno. Estas bibliotecas han sido golpeada muchas veces. Así es mucho más a prueba de balas de la nada ou puede venir a usted
    Véase también bioinformatics.org/phplabware/internal_utilities/htmLawed . Desde mi entender WordPress utiliza una versión anterior, core.trac.wordpress.org/browser/tags/2.9.2/wp-includes/kses.php

    OriginalEl autor jasonbar

  7. 15

    Un truco que puede ayudar en el caso específico de donde se tiene una página como /mypage?id=53 y utilizar el id en una cláusula where es para asegurarse de que el id definitivamente es un número entero, así:

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

    Pero, por supuesto, que sólo se corta un ataque específico, así que lea todas las otras respuestas. (Y sí, sé que el código anterior no es gran cosa, pero es una muestra de la defensa específica.)

    Yo uso $id = intval($id) lugar 🙂
    Casting entero es una buena manera de asegurarse de que sólo se insertan datos numéricos.
    $id = (int)$_GET['id'] y $que = sprintf('SELECT ... WHERE id="%d"', $id) es demasiado bueno

    OriginalEl autor Hamish Downer

  8. 10

    Lo que está describiendo aquí hay dos cuestiones distintas:

    1. Desinfección /filtrado de datos de entrada.
    2. Escapar de salida.

    1) entrada de Usuario siempre debe ser asumida como malo.

    El uso de declaraciones preparadas, o/y filtrado con mysql_real_escape_string es sin duda una visita.
    PHP también tiene filter_input integrado que es un buen lugar para empezar.

    2) Este es un gran tema, y de ella depende en el contexto de los datos de salida. En HTML existen soluciones como htmlpurifier por ahí.
    como regla general, siempre se escape nada de resultados.

    Ambas cuestiones son demasiado grandes para entrar en un solo post, pero hay un montón de puestos que entrar en más detalles:

    Métodos de PHP salida

    Seguro de PHP salida

    OriginalEl autor Andrew

  9. 5

    Métodos para la desinfección de la entrada del usuario con PHP:

    • La utilización de Modernas Versiones de MySQL y PHP.

    • Conjunto de caracteres de forma explícita:

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

        manual

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

        manual

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

        manual

      • $pdo = new PDO( 
        "mysql:host=$host;dbname=$db, $usuario, $pass, 
        array( 
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, 
        PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8" 
        ) 
        );

        manual

      • mysql_set_charset('utf8')

        [obsoleto en PHP 5.5.0, eliminado en PHP 7.0.0].

    • El uso seguro de los conjuntos de caracteres:

      • Seleccione utf8, latin1, ascii.., no uso vulnerables conjuntos de caracteres big5, cp932, gb2312, jds, sjis.
    • Uso espacializada función:

      • MySQLi declaraciones preparadas:
        $stmt = $mysqli- > prepare ("SELECT * FROM prueba where name = ? LÍMITE de 1'); 
        $param = "' or 1=1 /*";
        $stmt- > bind_param('s', $param);
        $stmt- > execute();
      • PDO::cotización() – lugares comillas alrededor de la cadena de entrada (si es necesario) y se escapa los caracteres especiales dentro de la cadena de entrada, el uso de un citando el estilo apropiado para el controlador subyacente:

        $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $usuario, $password);conjunto explícito el conjunto de caracteres
        $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);desactivar la emulación de sentencias preparadas para prevenir el retroceso a emular las declaraciones que MySQL no puede preparar de forma nativa (para evitar la inyección)
        $var = $pdo->de comillas (""' or 1=1 /*");no sólo escapa a la literal, pero también lo cita (en comillas simples ' caracteres) $stmt = $pdo- > query("SELECT * FROM prueba where name = $var LIMIT 1");

      • PDO Declaraciones Preparadas: vs MySQLi declaraciones preparadas admite más controladores de base de datos y parámetros con nombre:

        $pdo = new PDO('mysql:host=localhost;dbname=testdb;charset=UTF8', $usuario, $password);conjunto explícito el conjunto de caracteres
        $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);desactivar la emulación de sentencias preparadas para prevenir el retroceso a emular las declaraciones que MySQL no puede preparar de forma nativa (para evitar la inyección) $stmt = $pdo- > prepare ("SELECT * FROM prueba where name = ? LÍMITE de 1'); $stmt->ejecutar(["' O 1=1 /*"]);

      • mysql_real_escape_string [obsoleto en PHP 5.5.0, eliminado en PHP 7.0.0].
      • mysqli_real_escape_string Escapa los caracteres especiales en una cadena para su uso en una sentencia SQL, teniendo en cuenta el conjunto de caracteres actual de la conexión. Pero recomienda el uso de Declaraciones Preparadas, porque ellos no son simplemente escapó de las cadenas, una declaración viene con un completo plan de ejecución de consulta, incluyendo las tablas y los índices que se utilizan, es un optimizada.
      • Uso de comillas simples (‘ ‘) alrededor de las variables en el interior de su consulta.
    • Compruebe la variable contiene lo que usted está esperando para:

      • Si usted está esperando un entero, utilice:
        ctype_digit — Comprobación de carácter numérico(s);
        $valor = (int) $valor;
        $valor = intval($valor);
        $var = filter_var('0755', FILTER_VALIDATE_INT, $opciones);
      • Para las Cadenas de uso:
        is_string() — averiguar si el tipo de una variable de cadena

        Uso Función De Filtro filter_var() — filtros de una variable con un filtro especificado:

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

        más filtros predefinidos

      • filter_input() — Consigue un externo específico de la variable por su nombre y, opcionalmente, los filtros:
        $search_html = filter_input(INPUT_GET, 'la búsqueda', FILTER_SANITIZE_SPECIAL_CHARS);
      • preg_match() — Realizar una coincidencia de la expresión regular;
      • Escribir Su propia función de validación.

    OriginalEl autor Mark Martin

  10. 5

    Si usted está usando PostgreSQL, la entrada de PHP puede ser escapado con pg_escape_string()

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

    De la documentación (http://php.net/manual/es/function.pg-escape-string.php):

    pg_escape_string() escapa de una cadena para la consulta de la base de datos. Devuelve un escapó de la cadena en el PostgreSQL formato de sin comillas.

    pg_escape_literal() es el recomendado de la función a utilizar para PostgreSQL.

    OriginalEl autor Alejandro Silva

  11. 4

    Manera más fácil de evitar errores en la desinfección de entrada y escapar de datos usando PHP framework como Symfony, Nette etc. o parte de ese marco (motor de plantillas, capa de base de datos, ORM).

    Motor de plantillas como Ramita o Latte tiene salida de escape en forma predeterminada, por lo que no tienen que resolver de forma manual si tiene correctamente escapado a su salida, dependiendo del contexto (HTML o Javascript parte de la página web).

    Marco es automáticamente desinfección de entrada y usted no debe usar $_POST, $_GET o $_SESSION variables directamente, sino a través de mecanismos como el fresado, manejo de sesiones, etc.

    Y para la base de datos (modelo) de la capa hay ORM marcos como Doctrina o contenedores de PDO como Nette de la Base de datos.

    Usted puede leer más acerca de esto aquí – ¿Qué es un framework de software?

    OriginalEl autor Ondřej Šotek

  12. 3

    No hay cajón de la función, porque hay varias cuestiones que se abordarán.

    1. De Inyección de SQL – Hoy en día, por lo general, cada proyecto de PHP debe ser el uso de declaraciones preparadas a través de Objetos de Datos de PHP (PDO) como una mejor práctica, la prevención de un error de un callejero de la cita, así como una solución completa contra de la inyección. Es también la más flexible & forma segura de acceder a su base de datos.

      Retirar (El correcto) PDO tutorial para casi todo lo que necesita saber acerca de PDO. (Agradecimiento sincero a la parte superior por LO que el aportante, @YourCommonSense, para este gran recurso sobre el tema.)

    2. XSS – Desinfectar los datos sobre la forma en…

      • HTML Purifier ha sido alrededor de un largo tiempo y todavía está activamente actualizado. Se puede utilizar para desinfectar malicioso de entrada, mientras que todavía permite una generosa & configurable de la lista blanca de etiquetas. Funciona muy bien con muchos de los editores WYSIWYG, pero puede ser pesado para algunos casos de uso.

      • En otros casos, donde no queremos aceptar HTML/Javascript a todos, he encontrado esta sencilla función útil (y ha pasado varias auditorías contra 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 – Desinfectar los datos sobre la manera de salir… a menos que usted garantiza que los datos fueron debidamente desinfectados antes de agregarlo a la base de datos, debes desinfectarlo antes de mostrarlo al usuario, se pueden aprovechar estas útiles funciones de PHP:

      • Cuando llame echo o print para mostrar suministrado por el usuario, los valores, el uso de htmlspecialchars a menos que los datos fueron debidamente desinfectados segura y puede mostrar HTML.
      • json_encode es una manera segura para proporcionar suministrado por el usuario, los valores de PHP a Javascript
    4. Cómo se llama externo shell de comandos de uso de exec() o system() funciones, o a la backtick operador? Si es así, además de la Inyección de SQL & XSS que podría tener una preocupación adicional a la dirección, a los usuarios ejecutar comandos maliciosos en su servidor. Usted necesidad de utilizar escapeshellcmd si quieres escapar de todo el comando O escapeshellarg para escapar de los argumentos individuales.

    OriginalEl autor webaholik

  13. 2

    Sólo quería añadir que, en el tema de la salida de escape, si utiliza php DOMDocument para hacer su salida html automáticamente de escape en el contexto adecuado. Un atributo (valor=»») y el interior del texto de un <span> no son iguales.
    Para ser segura contra XSS leer esto:
    OWASP XSS Prevención de la Hoja de Trucos

    OriginalEl autor user138720

  14. 1

    Nunca desinfectar entrada.

    Siempre desinfectar salida.

    Las transformaciones que se aplican a los datos para que sea segura para su inclusión en una instrucción SQL son completamente diferentes de aquellos en los que se aplican para su inclusión en HTML son completamente diferentes de aquellos en los que se aplican para su inclusión en Javascript son completamente diferentes de aquellos en los que se aplican para su inclusión en LDIF son completamente diferentes de aquellos en los que se aplican a la inclusión en CSS son completamente diferentes de aquellos en los que se aplican a la inclusión en un Correo electrónico….

    Por todos los medios validar la entrada – decidir si usted debe aceptarlo para su posterior procesamiento o decirle al usuario que es inaceptable. Pero no se aplican cualquier cambio a la representación de los datos hasta que esté a punto de dejar de PHP de la tierra.

    Hace mucho tiempo que alguien trató de inventar una talla se adapta a todos mecanismo para escapar de datos y terminamos con «magic_quotes» el que no correctamente escapar de datos para todos los destinos de salida y resultó en la instalación diferentes requieren diferentes código de trabajo.

    OriginalEl autor symcbean

  15. 0

    No es el filtro de extensión (howto-link, manual), que funciona bastante bien con todas las GPC variables. No es una magia de hacer cualquier cosa, sin embargo, usted todavía tiene que usar.

    OriginalEl autor Till

  16. 0

    Nunca confiar en los datos de usuario.

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

    La trim() función elimina los espacios en blanco y otros caracteres predefinidos de ambos lados de una cadena.

    La stripslashes() función elimina las barras invertidas

    La htmlspecialchars() función convierte algunos caracteres predefinidos a entidades HTML.

    Los caracteres predefinidos son:

    & (ampersand) becomes &amp;
    " (double quote) becomes &quot;
    ' (single quote) becomes &#039;
    < (less than) becomes &lt;
    > (greater than) becomes &gt;
    He añadido un poco más de información para este ejemplo práctico.

    OriginalEl autor Erik Thiart

  17. -4

    El mejor método BÁSICO para la desinfección de la entrada del usuario con 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;
    }
    Por lo que usar real_escape_string() escapar especial de SQL caracteres, a continuación, ejecute sanitizeString() que se ejecuta stripslashes() y tiras de cualquier escape que se ha hecho. Así que, básicamente, agregar SQL protección, a continuación, quitar en el mismo paso. ¿Por qué estás aún usando stripslashes? Estas dos funciones son una terrible manera de desinfectar, incluso para los servicios BÁSICOS de saneamiento.

    OriginalEl autor vuchkov

Dejar respuesta

Please enter your comment!
Please enter your name here