Buscando métodos para solventar el SQL-Inyection usando PHP y MySQL

Demás esta decir que PHP y MySQL son unos de las herramientas más utilizadas en el desarrollo web, para nosotros en la escuela de ICB (http://icb.utalca.cl), puede ser un problema que estamos intentando resolver, y acá detallo una primera aproximación para dar solución a este ya común problema de seguridad.

Uno de las cosas comunes que nos encontramos en la web es simplemente la forma en como funcionan las cosas, por más que vengan de sitios confiables como php.net, W3Schools o stackoverflow, debemos primero saber si funciona para el modo de aprendizaje y lo segundo (cosa que nunca hacemos) es fijarnos en lo horrible que puede estar el código. La palabra horrible no solo la describo por lo feo que puede estar el código expresado linea a linea, sino que tambien ahora también por lo comprometido en cuanto a seguridad puede estar.

El típico ejemplo que encontramos en W3Schools para la pregunta ¿Cómo usar PHP y MySQL? (How to PHP+MySQL) es el siguiente:

   1  <?php
   2 $servername = "localhost";
   3 $username = "username";
   4 $password = "password";
   5 $id = $POST["code"]
   6 
   7 // Create connection
   8 $conn = new mysqli($servername, $username, $password);
   9 // Check connection
  10 if ($conn->connect_error) {
  11     die("Connection failed: " . $conn->connect_error);
  12 }
  13 
  14 // Create database
  15 $sql = "SELECT * FROM table WHERE id='$id'";
  16 if ($conn->query($sql) === TRUE) {
  17     echo "Query successfully";
  18 } else {
  19     echo "Error creating database: " . $conn->error;
  20 }
  21 
  22 $conn->close();
  23 ?>

Los problemas

La entrada de texto por parte del usuario es manipulada sin ningún tipo de parser, logrando que esto sea altamente vulnerable para un ataque por inyección de SQL o simplemente por error de tipeo el usuario logre datos no deseados. Entonces como regla es realizar siempre la implementación de una rutina que filtre lo que el usuario está escribiendo en los campos de entradas para completar el SQL, o bien usar de "prepared" o "escape" para las sentencias escritas.

Para el ejemplo anterior, la función de mysql_query() o myqli_query() es usada de forma directa en el código, y esta muy bien, pero esto es tratado para un tutorial, o sea es solo una referencia o demostración de como funciona o de como se podría implementar y no para usar tal cual.

En el caso lo que sucede es que la conexión a la base de datos es creada de forma manual y otro error que es común ver, las credenciales están en el mismo archivo en que ejecutarás la sentencia. Las buenas prácticas dicen que se debería crear algo que podamos manejar, primero de un modo centralizado como por ejemplo en un fichero separado con tags identificables que permitan importar el fichero a nuestro script php, y lo Segundo es ofuscar un poco el modo o el lugar, por ejemplo si utilizas los ficheros en el /ROOT/ del sitio (visible por nosotros), intenta por lo menos dificultar la exposición este tipo de credenciales. Nuevamente, el ejemplo encontrado esto es solo a modo de tutorial.

¿Qué se puede hacer?

Primero que todo, el controlador que utilizo para MySQL es mysqli, y en PHP existen dos formas de como manipularlo, la primera es a través de un método procedimental (funciones) o la orientación a objetos. En cuanto a la sintaxis es prácticamente igual, pero cambia en la forma de como se hace la referencia hacia las funciones (modo independiente o en un objeto de mysqli).

La forma de conexión:

   1 <?php
   2 // Try and connect to the database
   3 $connection = mysqli_connect($host,$username,$password,$dbname);
   4 
   5 // If connection was not successful, handle the error
   6 if($connection === false) {
   7 // Handle error - notify administrator, log to a file, show an error screen, etc.
   8 }
   9 ?>

La explicación para este fragmento sería; para mysqli_connect se requieren 4 parámetros esenciales como mínimo para crear la conexion (el host, usuario, contraseñas y nombre de base de datos). Existen otros parámetros que dependerán de la implementación del servidor, pero para ello se puede ver el siguiente link http://www.php.net/manual/en/mysqli.construct.php

Lo siguiente es validar la conexión, está demás decir que existen varios tipos de fallos de conectividad, por lo que se puede realizar un log file, error page, etc. quedando a la creatividad del desarrollador. El mensaje por pantalla es una opción buena y válida, pero cuidado con lo que muestras, puede dar pistas a un atacante y crear una vulnerabilidad.

Para el fragmento de código entregado requiere pasar los parámetros de conexión. Como ya he mencionado anteriormente, no es una buena práctica mantener a los de acceso a la conexión de base de datos, especialmente si los archivos PHP están dentro del /ROOT del website. El por qué se resumen principalmente que ante cualquier fallo o instancia de anormalidad del servidor web pudiese mostrarlo como texto en pantalla revelando información sensible para nosotros.

A mí me gusta mantener los parámetros de la base de datos separado de los archivos php, esto me permite hacer referencia en cualquier momento para hacer cambios generales en mis aplicaciones PHP.

Creo un documento de texto que contenga lo siguiente:

[database]
username = root
password = 1234
dbname = mydb
host = localhost

La extensión del fichero pasa un poco a ser irrelevante, pero generalmente uso las extensiones ini, rc o txt

Si se escoge, así como se proponen los scripts (https://github.com/erangalp/database-tutorial) una extensión .ini, la carga sería:

   1 <?php
   2 // Load configuration as an array. Use the actual location of your configuration file
   3 $config = parse_ini_file('/ROOT/../config.ini');
   4 
   5 // Try and connect to the database
   6 $connection = mysqli_connect($config['host'],$config['username'],$config['password'],$config['dbname']);
   7 
   8 // If connection was not successful, handle the error
   9 if($connection === false) {
  10     // Handle error - notify administrator, log to a file, show an error screen, etc.
  11 }
  12 ?>

Todo lo anterior podemos ponerlo dentro de una clase (para trabajar en orientación a objetos) y dentro de esa clase declarar una función para establecer la conexión

   1 <?php
   2 class Db {
   3     // The database connection
   4     protected static $connection;
   5 
   6     /**
   7      * Connect to the database
   8      *
   9      * @return bool false on failure / mysqli MySQLi object instance on success
  10      */
  11     public function connect() {
  12         // Try and connect to the database
  13         if(!isset(self::$connection)) {
  14             // Load configuration as an array. Use the actual location of your configuration file
  15             $config = parse_ini_file('/ROOT/../config.ini');
  16             self::$connection = new mysqli('localhost',$config['username'],$config['password'],$config['dbname']);
  17         }
  18 
  19         // If connection was not successful, handle the error
  20         if(self::$connection === false) {
  21             // Handle error - notify administrator, log to a file, show an error screen, etc.
  22             return false;
  23         }
  24         return self::$connection;
  25     }
  26 ?>

Consultando a la base de datos MySQL:

Ahora que se tiene la conexión, podemos comenzar a utilizar el motor de base de datos.

Según los tutoriales de php.net y W3Schools la forma de establecer una consulta es del siguiente modo:

   1 <?php
   2 // Connect to the database
   3 $connection = db_connect();
   4 
   5 // Query the database
   6 $result = mysqli_query($connection,$query);
   7 ?>

Esto ahora se inserta en una función pública dejando de este modo:

   1 <?php
   2     public function query($query) {
   3         // Connect to the database
   4         $connection = $this -> connect();
   5 
   6         // Query the database
   7         $result = $connection -> query($query);
   8 
   9         return $result;
  10     }
  11 
  12 ?>

El parámetro que recibe esta función es $query, que sería una sentencia SQL que se desea. Existe un pero, en el caso de que sea una sentencia SELECT que requiere la devolución de resultados, quizás sea mejor separar en funciones los query y generar una solo para esta.

   1 <?php
   2     function db_select($query) {
   3         $rows = array();
   4         $result = db_query($query);
   5 
   6         // If query failed, return `false`
   7         if($result === false) {
   8             return false;
   9         }
  10 
  11         // If query was successful, retrieve all the rows into an array
  12         while ($row = mysqli_fetch_assoc($result)) {
  13             $rows[] = $row;
  14         }
  15         return $rows;
  16     }
  17 
  18 ?>

Cuando se utiliza mysqli_fetch_assoc, recibiremos columnas del objeto mysqli_result, que serán del tipo array, que a su vez estarán indexados con las columnas de la base de datos.

Por último debemos generar un parser que sea dinámico para las entradas de los datos para los usuarios. El fin de este es importantisimo, puesto a que esta función sustituirá los valores de la variables declaradas para la entrada de datos cuando estos sean desconocidos. Hay algunos caracteres que usados por ejemplo entre comillas logran retornar valores o bien permite que se rompa nuestra consulta, creando una vulnerabilidad (ataque de inyección SQL).

Para esto mysqli tiene una función que nos ayuda mucho, mysqli_real_scape_string(). Esta función requiere de la conexión a la base de datos y los valores que queremos "limpiar".

La forma sería:

   1 <?php
   2 function db_quote($value) {
   3         $connection = db_connect();
   4         return "'" . mysqli_real_escape_string($connection,$value) . "'";
   5 }
   6 ?>

Y una forma de uso para eso:

   1 <?php
   2 // Quote and escape form submitted values
   3 $name = db_quote($_POST['username']);
   4 $email = db_quote($_POST['email']);
   5 
   6 // Insert the values into the database
   7 $result = db_query("INSERT INTO `users` (`name`,`email`) VALUES (" . $name . "," . $email . ")");
   8 ?>

Hace mucho tiempo yo utilizo unos script de Eran Galperin, que son licenciado MIT License. Pueden descargarse desde https://github.com/erangalp/database-tutorial y la estructura creada está basado en los ficheros del repositorio.