query - su servidor php no tiene cargado el módulo mysql o no puede usar las funciones mysql_ p connect




¿Por qué no debería usar las funciones mysql_*en PHP? (10)

Facilidad de uso

Las razones analíticas y sintéticas ya fueron mencionadas. Para los recién llegados, hay un incentivo más importante para dejar de usar las funciones mysql_ con fecha.

Las API de bases de datos contemporáneas son más fáciles de usar.

Es sobre todo los parámetros enlazados que pueden simplificar el código. Y con share la transición a la PDO no es demasiado ardua.

Volver a escribir una base de código más grande a la vez, sin embargo, lleva tiempo. Razón de ser de esta alternativa intermedia:

Funciones pdo_ * equivalentes en lugar de mysql_ *

Usando <pdo_mysql.php> puede cambiar las antiguas funciones mysql_ con un mínimo esfuerzo . Añade pdo_ función pdo_ que reemplazan a sus contrapartes mysql_ .

  1. Simplemente include_once( <pdo_mysql.php> ); en cada script de invocación que tiene que interactuar con la base de datos.

  2. Elimine el prefijo de la función mysql_ todas partes y reemplácelo con pdo_ .

    • mysql_ connect() convierte en pdo_ connect()
    • mysql_ query() convierte en pdo_ query()
    • mysql_ num_rows() convierte en pdo_ num_rows()
    • mysql_ insert_id() convierte en pdo_ insert_id()
    • mysql_ fetch_array() convierte en pdo_ fetch_array()
    • mysql_ fetch_assoc() convierte en pdo_ fetch_assoc()
    • mysql_ real_escape_string() convierte en pdo_ real_escape_string()
    • y así...

  3. Su código funcionará de la misma manera y aún así se verá igual:

    include_once("pdo_mysql.php"); 
    
    pdo_connect("localhost", "usrABC", "pw1234567");
    pdo_select_db("test");
    
    $result = pdo_query("SELECT title, html FROM pages");  
    
    while ($row = pdo_fetch_assoc($result)) {
        print "$row[title] - $row[html]";
    }
    

Et voilà.
Su código está utilizando DOP.
Ahora es el momento de utilizarlo .

Los parámetros de enlace pueden ser fáciles de usar

Solo necesitas una API menos manejable.

pdo_query() agrega un soporte muy fácil para los parámetros enlazados. Convertir código antiguo es sencillo:

Mueve tus variables fuera de la cadena SQL.

  • pdo_query() como parámetros de función delimitados por comas a pdo_query() .
  • Colocar signos de interrogación ? como marcadores de posición donde estaban las variables antes.
  • Deshágase de ' comillas simples que anteriormente incluían valores / variables de cadena.

La ventaja se vuelve más obvia para el código más largo.

A menudo, las variables de cadena no solo se interpolan en SQL, sino que se concatenan con llamadas de escape entre ellas.

pdo_query("SELECT id, links, html, title, user, date FROM articles
   WHERE title='" . pdo_real_escape_string($title) . "' OR id='".
   pdo_real_escape_string($title) . "' AND user <> '" .
   pdo_real_escape_string($root) . "' ORDER BY date")

Con ? Los marcadores de posición aplicados no tienen que preocuparse por eso:

pdo_query("SELECT id, links, html, title, user, date FROM articles
   WHERE title=? OR id=? AND user<>? ORDER BY date", $title, $id, $root)

Recuerda que pdo_ * todavía permite o .
Simplemente no escape una variable y vincúlela en la misma consulta.

  • La característica de marcador de posición es proporcionada por el PDO real detrás de él.
  • Así también permitido :named listas de marcadores de posición más adelante.

Lo más importante es que puede pasar las variables $ _REQUEST [] de forma segura detrás de cualquier consulta. Cuando los campos <form> enviados coinciden exactamente con la estructura de la base de datos, es incluso más corto:

pdo_query("INSERT INTO pages VALUES (?,?,?,?,?)", $_POST);

Tanta simplicidad. Pero volvamos a algunos consejos de reescritura y razones técnicas sobre por qué querrá deshacerse de mysql_ y escapar.

Corrige o elimina cualquier función de sanitize() vieja escuela

Una vez que haya convertido todas mysql_ llamadas mysql_ a pdo_query con pdo_query enlazados, elimine todas las llamadas redundantes pdo_real_escape_string .

En particular, debe corregir cualquier función de sanitize o clean o clean_data o de datos de clean_data como lo anuncian los tutoriales con fecha de una forma u otra:

function sanitize($str) {
   return trim(strip_tags(htmlentities(pdo_real_escape_string($str))));
}

El error más deslumbrante aquí es la falta de documentación. Más significativamente, el orden de filtrado fue exactamente en el orden incorrecto.

  • El orden correcto habría sido: desaprobar las stripslashes como la llamada más interna, luego trim , luego strip_tags , htmlentities para el contexto de salida, y solo por último la _escape_string como su aplicación debería preceder directamente a la interpersión de SQL.

  • Pero como primer paso simplemente deshacerse de la llamada _real_escape_string .

  • Es posible que deba conservar el resto de la función sanitize() por ahora si su base de datos y el flujo de aplicaciones esperan cadenas seguras para el contexto HTML. Agregue un comentario que aplique solo HTML que se escapa de aquí en adelante.

  • El manejo de cadena / valor se delega a PDO y sus declaraciones parametrizadas.

  • Si hubo alguna mención de stripslashes() en su función de desinfección, puede indicar una supervisión de nivel superior.

    Nota histórica sobre magic_quotes. Esa característica está en desuso. Sin embargo, a menudo se presenta incorrectamente como una característica de seguridad fallida. Pero los magic_quotes son tanto una característica de seguridad fallida como las pelotas de tenis que han fallado como fuente de nutrición. Eso simplemente no era su propósito.

    La implementación original en PHP2 / FI lo introdujo explícitamente con solo "las comillas se escaparán automáticamente, lo que facilitará el paso de los datos del formulario directamente a las consultas msql ". En particular, fue accidentalmente seguro de usar con mSQL , ya que solo ASCII era compatible.
    Luego PHP3 / Zend reintrodujo magic_quotes para MySQL y lo documentó mal. Pero originalmente solo era una característica de conveniencia , no una intención de seguridad.

Cómo difieren las declaraciones preparadas

Cuando codifica variables de cadena en las consultas SQL, no solo se vuelve más intrincado para que usted las siga. También es un esfuerzo extraño para MySQL segregar código y datos nuevamente.

Las inyecciones de SQL son simplemente cuando los datos sangran en el contexto del código . Un servidor de base de datos no puede ver más tarde dónde PHP originalmente pegaba las variables entre las cláusulas de consulta.

Con los parámetros enlazados, se separan el código SQL y los valores de contexto SQL en su código PHP. Pero no se vuelve a barajar entre bambalinas (excepto con DOP :: EMULATE_PREPARES). Su base de datos recibe los comandos SQL no variados y los valores de las variables 1: 1.

Si bien esta respuesta hace hincapié en que debería preocuparse por las ventajas de legibilidad de soltar mysql_ . Ocasionalmente, también hay una ventaja de rendimiento (repetidos INSERTs con solo valores diferentes) debido a esta separación visible de datos y códigos técnicos.

Tenga en cuenta que el enlace de parámetros aún no es una solución mágica de ventanilla única contra todas las inyecciones de SQL. Maneja el uso más común para datos / valores. Pero no se pueden incluir en la lista blanca los identificadores de nombres / tablas, la ayuda con la construcción de cláusulas dinámicas o simplemente listas de valores de matriz.

Uso híbrido de PDO

Estas funciones de envoltorio pdo_* hacen una API de pdo_* fácil de codificar. (Es más o menos lo que MYSQLI podría haber sido si no fuera por el cambio de firma de la función idiosincrásica). También exponen la verdadera DOP en la mayoría de los casos.
La reescritura no tiene que detenerse en el uso de los nuevos nombres de función pdo_. Podrías hacer una transición de cada uno pdo_query () a una llamada simple $ pdo-> prepare () -> execute ().

Sin embargo, es mejor comenzar con la simplificación de nuevo. Por ejemplo, la obtención de resultados comunes:

$result = pdo_query("SELECT * FROM tbl");
while ($row = pdo_fetch_assoc($result)) {

Se puede reemplazar con solo una iteración foreach:

foreach ($result as $row) {

O mejor aún, una recuperación de matriz directa y completa:

$result->fetchAll();

Obtendrá advertencias más útiles en la mayoría de los casos que PDO o mysql_ generalmente proporcionan después de consultas fallidas.

Otras opciones

Así que, con suerte, esto visualizó algunas razones prácticas y un camino valioso para soltar mysql_ .

Simplemente cambiando a pdo no es suficiente. pdo_query() también es solo una interfaz para él.

A menos que también introduzca el enlace de parámetros o pueda utilizar algo más de la API más agradable, es un interruptor sin sentido. Espero que sea retratado lo suficientemente simple como para no promover el desaliento a los recién llegados. (La educación generalmente funciona mejor que la prohibición).

Si bien califica para la categoría más simple de lo que podría funcionar, también es un código muy experimental. Acabo de escribirlo durante el fin de semana. Hay una gran cantidad de alternativas sin embargo. Solo busca la abstracción de la base de datos de PHP y navega un poco. Siempre ha habido y habrá muchas bibliotecas excelentes para tales tareas.

Si desea simplificar aún más la interacción de su base de datos, vale la pena probar Paris/Idiorm como Paris/Idiorm . Al igual que nadie más usa el DOM suave en JavaScript, no tiene que cuidar a una interfaz de base de datos sin procesar en la actualidad.

¿Cuáles son las razones técnicas por las que no se deben usar las funciones mysql_* ? (por ejemplo, mysql_query() , mysql_connect() o mysql_real_escape_string() )?

¿Por qué debería usar otra cosa incluso si funcionan en mi sitio?

Si no funcionan en mi sitio, ¿por qué recibo errores como

Advertencia: mysql_connect (): no existe tal archivo o directorio


La extensión de MySQL:

  • No está en desarrollo activo.
  • Está oficialmente en deprecated partir de PHP 5.5 (lanzado en junio de 2013).
  • Se ha removed completo a partir de PHP 7.0 (publicado en diciembre de 2015)
    • Esto significa que, a partir del 31 de diciembre de 2018 , no existirá en ninguna versión compatible de PHP. Actualmente, solo recibe actualizaciones de seguridad .
  • Carece de una interfaz OO
  • No soporta:
    • Consultas asíncronas no bloqueantes.
    • Declaraciones preparadas o consultas parametrizadas.
    • Procedimientos almacenados
    • Declaraciones multiples
    • Actas
    • El "nuevo" método de autenticación de contraseña (activado de forma predeterminada en MySQL 5.6; requerido en 5.7)
    • Toda la funcionalidad en MySQL 5.1.

Dado que está en desuso, su uso hace que su código sea una prueba menos futura.

La falta de soporte para las declaraciones preparadas es particularmente importante ya que proporcionan un método más claro y menos propenso a errores para escapar y citar datos externos que escapar manualmente con una llamada de función separada.

Ver la comparación de extensiones SQL .


Primero, comencemos con el comentario estándar que damos a todos:

share . Ya no se mantienen deprecated . ¿Ves la caja roja ? En su lugar, aprenda sobre declaraciones preparadas y use PDO o MySQLi ; este artículo lo ayudará a decidir cuál. Si elige DOP, aquí hay un buen tutorial .

Revisemos esto, oración por oración, y expliquemos:

  • Ya no se mantienen, y están oficialmente en desuso.

    Esto significa que la comunidad de PHP está disminuyendo gradualmente el soporte para estas funciones muy antiguas. ¡Es probable que no existan en una versión futura (reciente) de PHP! El uso continuado de estas funciones puede romper su código en un futuro (no tan) lejano.

    ¡NUEVO! - ¡ext / mysql ahora está deprecated

    ¡Más nuevo! ext / mysql ha sido eliminado en PHP 7 .

  • En su lugar, debe aprender de declaraciones preparadas

    mysql_* extensión mysql_* no admite declaraciones preparadas , lo cual es (entre otras cosas) una contramedida muy efectiva contra la inyección SQL . Se solucionó una vulnerabilidad muy grave en las aplicaciones dependientes de MySQL que permite a los atacantes obtener acceso a su script y realizar cualquier consulta posible en su base de datos.

    Para obtener más información, consulte ¿Cómo puedo evitar la inyección de SQL en PHP?

  • ¿Ver la caja roja?

    Cuando vaya a cualquier página de manual de la función mysql , verá un cuadro rojo, explicando que ya no se debe utilizar.

  • Utilice PDO o MySQLi

    Existen alternativas mejores, más sólidas y mejor construidas, PDO , que ofrece un enfoque completo de OOP para la interacción de la base de datos, y MySQLi , que es una mejora específica de MySQL.


Las funciones mysql_ * se depreciaron (a partir de php 5.5 ) dado que se desarrollaron mejores funciones y estructuras de código. El hecho de que la función se haya depreciado significa que no se harán más esfuerzos para mejorarla en términos de rendimiento y seguridad, lo que significa que es una prueba menos futura .

Si necesitas más razones:

  • Las funciones mysql_ * no admiten sentencias preparadas.
  • Las funciones mysql_ * no admiten el enlace de parámetros.
  • Las funciones mysql_ * carecen de funcionalidad para la programación orientada a objetos.
  • la lista continua ...

Esta respuesta está escrita para mostrar cuán trivial es omitir el código de validación de usuario de PHP mal escrito, cómo (y con qué) funcionan estos ataques y cómo reemplazar las antiguas funciones de MySQL con una declaración preparada de forma segura. (probablemente con muchas repeticiones) están ladrando a nuevos usuarios que hacen preguntas para mejorar su código.

En primer lugar, siéntase libre de crear esta base de datos de prueba de mysql (he llamado preparación mía):

mysql> create table users(
    -> id int(2) primary key auto_increment,
    -> userid tinytext,
    -> pass tinytext);
Query OK, 0 rows affected (0.05 sec)

mysql> insert into users values(null, 'Fluffeh', 'mypass');
Query OK, 1 row affected (0.04 sec)

mysql> create user 'prepared'@'localhost' identified by 'example';
Query OK, 0 rows affected (0.01 sec)

mysql> grant all privileges on prep.* to 'prepared'@'localhost' with grant option;
Query OK, 0 rows affected (0.00 sec)

Con eso hecho, podemos pasar a nuestro código PHP.

Supongamos que el siguiente script es el proceso de verificación para un administrador en un sitio web (simplificado pero funciona si lo copia y lo utiliza para realizar pruebas):

<?php 

    if(!empty($_POST['user']))
    {
        $user=$_POST['user'];
    }   
    else
    {
        $user='bob';
    }
    if(!empty($_POST['pass']))
    {
        $pass=$_POST['pass'];
    }
    else
    {
        $pass='bob';
    }

    $database='prep';
    $link=mysql_connect('localhost', 'prepared', 'example');
    mysql_select_db($database) or die( "Unable to select database");

    $sql="select id, userid, pass from users where userid='$user' and pass='$pass'";
    //echo $sql."<br><br>";
    $result=mysql_query($sql);
    $isAdmin=false;
    while ($row = mysql_fetch_assoc($result)) {
        echo "My id is ".$row['id']." and my username is ".$row['userid']." and lastly, my password is ".$row['pass']."<br>";
        $isAdmin=true;
        // We have correctly matched the Username and Password
        // Lets give this person full access
    }
    if($isAdmin)
    {
        echo "The check passed. We have a verified admin!<br>";
    }
    else
    {
        echo "You could not be verified. Please try again...<br>";
    }
    mysql_close($link);

?>

<form name="exploited" method='post'>
    User: <input type='text' name='user'><br>
    Pass: <input type='text' name='pass'><br>
    <input type='submit'>
</form>

Parece lo suficientemente legítimo a primera vista.

El usuario tiene que ingresar un nombre de usuario y contraseña, ¿verdad?

Brillante, no entrar en lo siguiente:

user: bob
pass: somePass

y enviarlo.

La salida es la siguiente:

You could not be verified. Please try again...

¡Súper! Trabajando como se esperaba, ahora probemos el nombre de usuario y la contraseña reales:

user: Fluffeh
pass: mypass

¡Increíble!Hi-fives all round, el código verificó correctamente a un administrador. ¡Es perfecto!

Bueno en realidad no. Digamos que el usuario es una personita inteligente. Digamos que la persona soy yo.

Ingrese en lo siguiente:

user: bob
pass: n' or 1=1 or 'm=m

Y la salida es:

The check passed. We have a verified admin!

Enhorabuena, solo me permitiste ingresar a tu sección de administradores súper protegidos solo cuando ingresé un nombre de usuario falso y una contraseña falsa. En serio, si no me cree, cree la base de datos con el código que proporcioné y ejecute este código PHP, que a simple vista parece verificar bastante bien el nombre de usuario y la contraseña.

Así que, en respuesta, ESO ES POR QUÉ ESTÁ AÚNTEO.

Entonces, echemos un vistazo a lo que salió mal, y por qué acabo de entrar en su cueva de murciélagos solo para administradores. Tomé una conjetura y asumí que no estaba siendo cuidadoso con sus entradas y simplemente las pasó directamente a la base de datos. Construí la entrada de una manera que CAMBIARÍA la consulta que realmente estaba ejecutando. Entonces, ¿qué se suponía que era y qué terminó siendo?

select id, userid, pass from users where userid='$user' and pass='$pass'

Esa es la consulta, pero cuando reemplazamos las variables con las entradas reales que usamos, obtenemos lo siguiente:

select id, userid, pass from users where userid='bob' and pass='n' or 1=1 or 'm=m'

¿Vea cómo construí mi "contraseña" de modo que primero cierre la comilla alrededor de la contraseña y luego introduzca una comparación completamente nueva? Luego, solo por seguridad, agregué otra "cadena" para que la comilla simple se cierre como se esperaba en el código que originalmente teníamos.

Sin embargo, esto no se trata de que la gente te grite ahora, se trata de mostrarte cómo hacer que tu código sea más seguro.

De acuerdo, entonces, ¿qué salió mal y cómo podemos solucionarlo?

Este es un ataque clásico de inyección SQL. Uno de los más simples para el caso. En la escala de vectores de ataque, este es un niño pequeño que ataca un tanque y gana.

Entonces, ¿cómo protegemos su sección de administrador sagrado y la hacemos agradable y segura? Lo primero que debe hacer es dejar de usar esas mysql_*funciones realmente antiguas y obsoletas . Lo sé, seguiste un tutorial que encontraste en línea y funciona, pero es antiguo, está desactualizado y en el espacio de unos minutos, lo he superado sin siquiera romper un sudor.

Ahora, tiene las mejores opciones de usar mysqli_ o PDO . Personalmente, soy un gran fanático de PDO, por lo que usaré PDO en el resto de esta respuesta. Hay profesionales y contras, pero personalmente encuentro que los profesionales superan con creces a los contras. Es portátil a través de múltiples motores de base de datos, ya sea que esté usando MySQL u Oracle o simplemente con cualquier cosa. Simplemente cambiando la cadena de conexión, tiene todas las funciones sofisticadas que queremos usar y es agradable y limpio. Me gusta limpiar

Ahora, echemos un vistazo a ese código nuevamente, esta vez escrito con un objeto PDO:

<?php 

    if(!empty($_POST['user']))
    {
        $user=$_POST['user'];
    }   
    else
    {
        $user='bob';
    }
    if(!empty($_POST['pass']))
    {
        $pass=$_POST['pass'];
    }
    else
    {
        $pass='bob';
    }
    $isAdmin=false;

    $database='prep';
    $pdo=new PDO ('mysql:host=localhost;dbname=prep', 'prepared', 'example');
    $sql="select id, userid, pass from users where userid=:user and pass=:password";
    $myPDO = $pdo->prepare($sql, array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
    if($myPDO->execute(array(':user' => $user, ':password' => $pass)))
    {
        while($row=$myPDO->fetch(PDO::FETCH_ASSOC))
        {
            echo "My id is ".$row['id']." and my username is ".$row['userid']." and lastly, my password is ".$row['pass']."<br>";
            $isAdmin=true;
            // We have correctly matched the Username and Password
            // Lets give this person full access
        }
    }

    if($isAdmin)
    {
        echo "The check passed. We have a verified admin!<br>";
    }
    else
    {
        echo "You could not be verified. Please try again...<br>";
    }

?>

<form name="exploited" method='post'>
    User: <input type='text' name='user'><br>
    Pass: <input type='text' name='pass'><br>
    <input type='submit'>
</form>

Las principales diferencias son que no hay más mysql_*funciones. Todo se hace a través de un objeto PDO, en segundo lugar, está utilizando una declaración preparada. Ahora, ¿qué es una declaración preparada que pides? Es una forma de decirle a la base de datos antes de ejecutar una consulta, qué consulta es la que vamos a ejecutar. En este caso, le decimos a la base de datos: "Hola, voy a ejecutar una instrucción de selección que desea id, ID de usuario y pase de la tabla a los usuarios, donde el ID de usuario es una variable y el paso también es una variable".

Luego, en la instrucción de ejecución, pasamos a la base de datos una matriz con todas las variables que ahora espera.

Los resultados son fantásticos. Vamos a probar esas combinaciones de nombre de usuario y contraseña de antes otra vez:

user: bob
pass: somePass

El usuario no fue verificado. Increíble.

Qué tal si:

user: Fluffeh
pass: mypass

Oh, me emocioné un poco, funcionó: el cheque pasó. Tenemos un administrador verificado!

Ahora, probemos los datos que un ingenioso tipo ingresaría para intentar superar nuestro pequeño sistema de verificación:

user: bob
pass: n' or 1=1 or 'm=m

Esta vez, obtenemos lo siguiente:

You could not be verified. Please try again...

Esta es la razón por la que le gritan cuando publica preguntas, es porque la gente puede ver que su código puede ser anulado sin siquiera intentarlo. Por favor, use esta pregunta y respuesta para mejorar su código, para hacerlo más seguro y para utilizar las funciones actuales.

Por último, esto no quiere decir que este es un código PERFECTO. Hay muchas más cosas que podría hacer para mejorarla; por ejemplo, use contraseñas con hash, asegúrese de que cuando almacena información sensetiva en la base de datos, no la almacene en texto sin formato, tenga múltiples niveles de verificación, pero realmente simplemente cambia su antiguo código propenso a la inyección a esto, estará muy bien en el camino para escribir un buen código, y el hecho de que haya llegado tan lejos y que todavía esté leyendo me da un sentido de esperanza de que no solo implementará este tipo del código al escribir sus sitios web y aplicaciones, pero puede salir e investigar esas otras cosas que acabo de mencionar, y más. Escriba el mejor código que pueda, no el código más básico que apenas funciona.


Es posible definir casi todas las mysql_*funciones usando mysqli o PDO. Solo inclúyalos sobre su antigua aplicación PHP, y funcionará en PHP7. Mi solución here .

<?php

define('MYSQL_LINK', 'dbl');
$GLOBALS[MYSQL_LINK] = null;

function mysql_link($link=null) {
    return ($link === null) ? $GLOBALS[MYSQL_LINK] : $link;
}

function mysql_connect($host, $user, $pass) {
    $GLOBALS[MYSQL_LINK] = mysqli_connect($host, $user, $pass);
    return $GLOBALS[MYSQL_LINK];
}

function mysql_pconnect($host, $user, $pass) {
    return mysql_connect($host, $user, $pass);
}

function mysql_select_db($db, $link=null) {
    $link = mysql_link($link);
    return mysqli_select_db($link, $db);
}

function mysql_close($link=null) {
    $link = mysql_link($link);
    return mysqli_close($link);
}

function mysql_error($link=null) {
    $link = mysql_link($link);
    return mysqli_error($link);
}

function mysql_errno($link=null) {
    $link = mysql_link($link);
    return mysqli_errno($link);
}

function mysql_ping($link=null) {
    $link = mysql_link($link);
    return mysqli_ping($link);
}

function mysql_stat($link=null) {
    $link = mysql_link($link);
    return mysqli_stat($link);
}

function mysql_affected_rows($link=null) {
    $link = mysql_link($link);
    return mysqli_affected_rows($link);
}

function mysql_client_encoding($link=null) {
    $link = mysql_link($link);
    return mysqli_character_set_name($link);
}

function mysql_thread_id($link=null) {
    $link = mysql_link($link);
    return mysqli_thread_id($link);
}

function mysql_escape_string($string) {
    return mysql_real_escape_string($string);
}

function mysql_real_escape_string($string, $link=null) {
    $link = mysql_link($link);
    return mysqli_real_escape_string($link, $string);
}

function mysql_query($sql, $link=null) {
    $link = mysql_link($link);
    return mysqli_query($link, $sql);
}

function mysql_unbuffered_query($sql, $link=null) {
    $link = mysql_link($link);
    return mysqli_query($link, $sql, MYSQLI_USE_RESULT);
}

function mysql_set_charset($charset, $link=null){
    $link = mysql_link($link);
    return mysqli_set_charset($link, $charset);
}

function mysql_get_host_info($link=null) {
    $link = mysql_link($link);
    return mysqli_get_host_info($link);
}

function mysql_get_proto_info($link=null) {
    $link = mysql_link($link);
    return mysqli_get_proto_info($link);
}
function mysql_get_server_info($link=null) {
    $link = mysql_link($link);
    return mysqli_get_server_info($link);
}

function mysql_info($link=null) {
    $link = mysql_link($link);
    return mysqli_info($link);
}

function mysql_get_client_info() {
    $link = mysql_link();
    return mysqli_get_client_info($link);
}

function mysql_create_db($db, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    return mysqli_query($link, "CREATE DATABASE `$db`");
}

function mysql_drop_db($db, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    return mysqli_query($link, "DROP DATABASE `$db`");
}

function mysql_list_dbs($link=null) {
    $link = mysql_link($link);
    return mysqli_query($link, "SHOW DATABASES");
}

function mysql_list_fields($db, $table, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    $table = str_replace('`', '', mysqli_real_escape_string($link, $table));
    return mysqli_query($link, "SHOW COLUMNS FROM `$db`.`$table`");
}

function mysql_list_tables($db, $link=null) {
    $link = mysql_link($link);
    $db = str_replace('`', '', mysqli_real_escape_string($link, $db));
    return mysqli_query($link, "SHOW TABLES FROM `$db`");
}

function mysql_db_query($db, $sql, $link=null) {
    $link = mysql_link($link);
    mysqli_select_db($link, $db);
    return mysqli_query($link, $sql);
}

function mysql_fetch_row($qlink) {
    return mysqli_fetch_row($qlink);
}

function mysql_fetch_assoc($qlink) {
    return mysqli_fetch_assoc($qlink);
}

function mysql_fetch_array($qlink, $result=MYSQLI_BOTH) {
    return mysqli_fetch_array($qlink, $result);
}

function mysql_fetch_lengths($qlink) {
    return mysqli_fetch_lengths($qlink);
}

function mysql_insert_id($qlink) {
    return mysqli_insert_id($qlink);
}

function mysql_num_rows($qlink) {
    return mysqli_num_rows($qlink);
}

function mysql_num_fields($qlink) {
    return mysqli_num_fields($qlink);
}

function mysql_data_seek($qlink, $row) {
    return mysqli_data_seek($qlink, $row);
}

function mysql_field_seek($qlink, $offset) {
    return mysqli_field_seek($qlink, $offset);
}

function mysql_fetch_object($qlink, $class="stdClass", array $params=null) {
    return ($params === null)
        ? mysqli_fetch_object($qlink, $class)
        : mysqli_fetch_object($qlink, $class, $params);
}

function mysql_db_name($qlink, $row, $field='Database') {
    mysqli_data_seek($qlink, $row);
    $db = mysqli_fetch_assoc($qlink);
    return $db[$field];
}

function mysql_fetch_field($qlink, $offset=null) {
    if ($offset !== null)
        mysqli_field_seek($qlink, $offset);
    return mysqli_fetch_field($qlink);
}

function mysql_result($qlink, $offset, $field=0) {
    if ($offset !== null)
        mysqli_field_seek($qlink, $offset);
    $row = mysqli_fetch_array($qlink);
    return (!is_array($row) || !isset($row[$field]))
        ? false
        : $row[$field];
}

function mysql_field_len($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    return is_object($field) ? $field->length : false;
}

function mysql_field_name($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    if (!is_object($field))
        return false;
    return empty($field->orgname) ? $field->name : $field->orgname;
}

function mysql_field_table($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    if (!is_object($field))
        return false;
    return empty($field->orgtable) ? $field->table : $field->orgtable;
}

function mysql_field_type($qlink, $offset) {
    $field = mysqli_fetch_field_direct($qlink, $offset);
    return is_object($field) ? $field->type : false;
}

function mysql_free_result($qlink) {
    try {
        mysqli_free_result($qlink);
    } catch (Exception $e) {
        return false;
    }
    return true;
}

Hay muchas razones, pero quizás la más importante es que esas funciones fomentan prácticas de programación inseguras porque no admiten declaraciones preparadas. Las declaraciones preparadas ayudan a prevenir los ataques de inyección SQL.

Cuando use mysql_*funciones, debe recordar ejecutar los parámetros proporcionados por el usuario a través de mysql_real_escape_string(). Si olvida en un solo lugar o si escapa solo parte de la entrada, su base de datos puede estar sujeta a ataques.

Usar declaraciones preparadas en PDOo mysqlilo hará para que este tipo de errores de programación sean más difíciles de cometer.


La extensión de MySQL es la más antigua de las tres y fue la forma original que los desarrolladores usaban para comunicarse con MySQL. Esta extensión ahora está en deprecated en favor de las otras mysqli_ PDO debido a las mejoras realizadas en las versiones más recientes de PHP y MySQL.

  • mysqli_ es la extensión 'mejorada' para trabajar con bases de datos MySQL. Aprovecha las características que están disponibles en las versiones más nuevas del servidor MySQL, expone una interfaz orientada a funciones y otra orientada a objetos al desarrollador y hace algunas otras cosas ingeniosas.

  • PDO ofrece una API que consolida la mayor parte de la funcionalidad que se extendió anteriormente en las principales extensiones de acceso a bases de datos, es decir, MySQL, PostgreSQL, SQLite, MSSQL, etc. La interfaz expone objetos de alto nivel para que el programador trabaje con conexiones de base de datos, consultas y los conjuntos de resultados y los controladores de bajo nivel realizan la comunicación y el manejo de recursos con el servidor de base de datos. Se está llevando a cabo una gran cantidad de discusión y trabajo en PDO y se considera el método apropiado para trabajar con bases de datos en un código moderno y profesional.


Las funciones que son similares a esta mysql_connect(), mysql_query()tipo son las versiones de la versión anterior PHP ie (PHP 4) y ahora no están en uso.

Estos son reemplazados por mysqli_connect(), de mysqli_query()manera similar en el último PHP5.

Esta es la razón detrás del error.


Porque (entre otras razones) es mucho más difícil garantizar que los datos de entrada se desinfecten. Si utiliza consultas parametrizadas, como una con PDO o mysqli, puede evitar el riesgo por completo.

Como ejemplo, alguien podría usarlo "enhzflep); drop table users"como nombre de usuario. Las funciones anteriores permitirán ejecutar varias instrucciones por consulta, por lo que algo así como el desagradable bugger puede eliminar una tabla completa.

Si uno fuera a usar la DOP de mysqli, el nombre de usuario terminaría siendo "enhzflep); drop table users".

Ver bobby-tables.com .





database