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 línea a línea, sino que 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 métodos "prepared" para postgreSQL o "escape" de mysqli 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 archivo separado con tags identificables que permitan importar el archivo a nuestro script php, y lo Segundo es ofuscar un poco el modo o el lugar, por ejemplo si utilizas los archivos 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 se puede utilizar para el manejo de MySQL es mysqli. En PHP existen dos formas de como manipularlo, la primera es a través de un método procedimental (funciones) y la segunda es la orientación a objetos. En cuanto a la sintaxis es prácticamente igual, pero cambia en la forma de como se referencia hacia las funciones (modo independiente o en un objeto de mysqli), por lo que ambas son válidas.
La forma de conexión:
La explicación para este fragmento sería; para mysqli_connect se requieren 4 parámetros esenciales como mínimo para crear la conexión (host, usuario, contraseñas, 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
Las siguientes lineas es validar la conexión, está demás decir que existen varios tipos de fallos de conectividad, siendo factible 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 se menciono 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. Es una buena opción 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 las aplicaciones.
Se crea un documento de texto que contenga lo siguiente:
[database] username = root password = 1234 dbname = mydb host = localhost
La extensión del archivo pasa un poco a ser irrelevante, pero generalmente uso las extensiones ini, rc o txt
La necesidad de mantener las credenciales separadas de los archivos php se resumen principalmente que ante cualquier fallo o instancia de anormalidad del servidor web, este pudiese revelar como texto en pantalla revelando las credenciales.
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 también 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:
Se Puede modificar esto y declarar una función pública como el siguiente ejemplo:
El parámetro que recibe esta función es $query, que requiere ser una sentencia SQL. 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 ?>
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.
Datos de entrada
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:
Los script resultantes
db.php
1 <?php
2
3 /**
4 * Database wrapper for a MySQL with PHP tutorial
5 *
6 * @copyright Eran Galperin
7 * @license MIT License
8 * @see http://www.binpress.com/tutorial/using-php-with-mysql-the-right-way/17
9 */
10 class Db {
11 // The database connection
12 protected static $connection;
13
14 /**
15 * Connect to the database
16 *
17 * @return bool false on failure / mysqli MySQLi object instance on success
18 */
19 public function connect() {
20
21 // Try and connect to the database
22 if(!isset(self::$connection)) {
23 // Load configuration as an array. Use the actual location of your configuration file
24 // Put the configuration file outside of the document root
25 $config = parse_ini_file('./config.ini');
26 self::$connection = new mysqli('localhost',$config['username'],$config['password'],$config['dbname']);
27 }
28
29 // If connection was not successful, handle the error
30 if(self::$connection === false) {
31 // Handle error - notify administrator, log to a file, show an error screen, etc.
32 return false;
33 }
34 return self::$connection;
35 }
36
37 /**
38 * Query the database
39 *
40 * @param $query The query string
41 * @return mixed The result of the mysqli::query() function
42 */
43 public function query($query) {
44 // Connect to the database
45 $connection = $this -> connect();
46
47 // Query the database
48 $result = $connection -> query($query);
49
50 return $result;
51 }
52
53 /**
54 * Fetch rows from the database (SELECT query)
55 *
56 * @param $query The query string
57 * @return bool False on failure / array Database rows on success
58 */
59 public function select($query) {
60 $rows = array();
61 $result = $this -> query($query);
62 if($result === false) {
63 return false;
64 }
65 while ($row = $result -> fetch_assoc()) {
66 $rows[] = $row;
67 }
68 return $rows;
69 }
70
71 /**
72 * Fetch the last error from the database
73 *
74 * @return string Database error message
75 */
76 public function error() {
77 $connection = $this -> connect();
78 return $connection -> error;
79 }
80
81 /**
82 * Quote and escape value for use in a database query
83 *
84 * @param string $value The value to be quoted and escaped
85 * @return string The quoted and escaped string
86 */
87 public function quote($value) {
88 $connection = $this -> connect();
89 return "'" . $connection -> real_escape_string($value) . "'";
90 }
91 }
Y una forma de uso para eso:
1 <?php
2 // Quote and escape form submitted values
3
4 include('./db.php');
5 $db = new Db();
6
7 $name = $db -> quote($_POST['username']);
8 $email = $db -> quote($_POST['email']);
9
10 // Insert the values into the database
11 $result = db -> query("INSERT INTO `users` (`name`,`email`) VALUES (" . $name . "," . $email . ")");
12
13 $rows = $db -> select("SELECT * FROM `users`");
14
15 foreach($rows as $row) {
16 echo "name: ". row['name'];
17 echo "email: ". row['email'];
18 }
19
20 ?>
Todo este documento se basó en unos script de Eran Galperin, licenciados con la MIT License. Pueden descargar desde https://github.com/erangalp/database-tutorial