= 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:

{{{#!highlight php
 <?php
$servername = "localhost";
$username = "username";
$password = "password";
$id = $POST["code"]

// Create connection
$conn = new mysqli($servername, $username, $password);
// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}

// Create database
$sql = "SELECT * FROM table WHERE id='$id'";
if ($conn->query($sql) === TRUE) {
    echo "Query successfully";
} else {
    echo "Error creating database: " . $conn->error;
}

$conn->close();
?>
}}}
=== 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: ====
{{{#!highlight php
<?php
// Try and connect to the database
$connection = mysqli_connect($host,$username,$password,$dbname);

// If connection was not successful, handle the error
if($connection === false) {
// Handle error - notify administrator, log to a file, show an error screen, etc.
}
?>
}}}
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.

{{{#!highlight php
<?php
// Load configuration as an array. Use the actual location of your configuration file
$config = parse_ini_file('/ROOT/../config.ini');

// Try and connect to the database
$connection = mysqli_connect($config['host'],$config['username'],$config['password'],$config['dbname']);

// If connection was not successful, handle the error
if($connection === false) {
    // Handle error - notify administrator, log to a file, show an error screen, etc.
}
?>
}}}
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

{{{#!highlight php
<?php
class Db {
    // The database connection
    protected static $connection;

    /**
     * Connect to the database
     *
     * @return bool false on failure / mysqli MySQLi object instance on success
     */
    public function connect() {
        // Try and connect to the database
        if(!isset(self::$connection)) {
            // Load configuration as an array. Use the actual location of your configuration file
            $config = parse_ini_file('/ROOT/../config.ini');
            self::$connection = new mysqli('localhost',$config['username'],$config['password'],$config['dbname']);
        }

        // If connection was not successful, handle the error
        if(self::$connection === false) {
            // Handle error - notify administrator, log to a file, show an error screen, etc.
            return false;
        }
        return self::$connection;
    }
?>
}}}
=== 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:

{{{#!highlight php
<?php
// Connect to the database
$connection = db_connect();

// Query the database
$result = mysqli_query($connection,$query);
?>
}}}
Se Puede modificar esto y declarar una función pública como el siguiente ejemplo:

{{{#!highlight php
<?php
public function query($query) {
    // Connect to the database
    $connection = $this -> connect();

    // Query the database
    $result = $connection -> query($query);

    return $result;
    }
?>
}}}
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.

{{{#!highlight php
<?php
function db_select($query) {
    $rows = array();
    $result = db_query($query);

    // If query failed, return `false`
    if($result === false) {
        return false;
    }

    // If query was successful, retrieve all the rows into an array
    while ($row = mysqli_fetch_assoc($result)) {
        $rows[] = $row;
    }
    return $rows;
}
?>
}}}
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, '''[[http://php.net/manual/es/mysqli.real-escape-string.php|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:

{{{#!highlight php
<?php
function db_quote($value) {
    $connection = db_connect();
    return "'" . mysqli_real_escape_string($connection,$value) . "'";
}
?>
}}}
=== Los script resultantes ===
'''db.php'''

{{{#!highlight php
<?php

/**
 * Database wrapper for a MySQL with PHP tutorial
 *
 * @copyright Eran Galperin
 * @license MIT License
 * @see http://www.binpress.com/tutorial/using-php-with-mysql-the-right-way/17
 */
class Db {
        // The database connection
        protected static $connection;

        /**
         * Connect to the database
         *
         * @return bool false on failure / mysqli MySQLi object instance on success
         */
        public function connect() {

                // Try and connect to the database
                if(!isset(self::$connection)) {
                        // Load configuration as an array. Use the actual location of your configuration file
                        // Put the configuration file outside of the document root
                        $config = parse_ini_file('./config.ini');
                        self::$connection = new mysqli('localhost',$config['username'],$config['password'],$config['dbname']);
                }

                // If connection was not successful, handle the error
                if(self::$connection === false) {
                        // Handle error - notify administrator, log to a file, show an error screen, etc.
                        return false;
                }
                return self::$connection;
        }

        /**
         * Query the database
         *
         * @param $query The query string
         * @return mixed The result of the mysqli::query() function
         */
        public function query($query) {
                // Connect to the database
                $connection = $this -> connect();

                // Query the database
                $result = $connection -> query($query);

                return $result;
        }

        /**
         * Fetch rows from the database (SELECT query)
         *
         * @param $query The query string
         * @return bool False on failure / array Database rows on success
         */
        public function select($query) {
                $rows = array();
                $result = $this -> query($query);
                if($result === false) {
                        return false;
                }
                while ($row = $result -> fetch_assoc()) {
                        $rows[] = $row;
                }
                return $rows;
        }

        /**
         * Fetch the last error from the database
         *
         * @return string Database error message
         */
        public function error() {
                $connection = $this -> connect();
                return $connection -> error;
        }

        /**
         * Quote and escape value for use in a database query
         *
         * @param string $value The value to be quoted and escaped
         * @return string The quoted and escaped string
         */
        public function quote($value) {
                $connection = $this -> connect();
                return "'" . $connection -> real_escape_string($value) . "'";
        }
}
}}}
Y una forma de uso para eso:

{{{#!highlight php
<?php
// Quote and escape form submitted values

include('./db.php');
$db = new Db();

$name = $db -> quote($_POST['username']);
$email = $db -> quote($_POST['email']);

// Insert the values into the database
$result = db -> query("INSERT INTO `users` (`name`,`email`) VALUES (" . $name . "," . $email . ")");

$rows = $db -> select("SELECT * FROM `users`");

foreach($rows as $row) {
    echo "name: ". row['name'];
    echo "email: ". row['email'];
}

?>
}}}
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