Logins seguros

daniela Vega ese código a parte de malo es muy viejo.

Ahora se usa el conector mysqli, no mysql

Ejemplos:

Código

$stmt = $dbConnection->prepare('SELECT * FROM employees WHERE name = ?');
$stmt->bind_param('s', $name);
 
$stmt->execute();
 
$result = $stmt->get_result();
while ($row = $result->fetch_assoc()) {
    // do something with $row
}

Código

<?php
    $mysqli = new mysqli("server", "username", "password", "database_name");
 
    // TODO - Check that connection was successful.
 
    $unsafe_variable = $_POST["user-input"];
 
    $stmt = $mysqli->prepare("INSERT INTO table (column) VALUES (?)");
 
    // TODO check that $stmt creation succeeded
 
    // "s" means the database expects a string
    $stmt->bind_param("s", $unsafe_variable);
 
    $stmt->execute();
 
    $stmt->close();
 
    $mysqli->close();
?>

Código

$name = $_GET['username'];
 
if ($stmt = $mysqli->prepare("SELECT password FROM tbl_users WHERE name=?")) {
 
    // Bind a variable to the parameter as a string. 
    $stmt->bind_param("s", $name);
 
    // Execute the statement.
    $stmt->execute();
 
    // Get the variables from the query.
    $stmt->bind_result($pass);
 
    // Fetch the data.
    $stmt->fetch();
 
    // Display the data.
    printf("Password for user %s is %s\n", $name, $pass);
 
    // Close the prepared statement.
    $stmt->close();
 
}

Código

<?php
 
/**
 * Check if the 'id' GET variable is set
 * Example - http://localhost/?id=1
 */
if (isset($_GET['id'])){
  $id = $_GET['id'];
  /**
   * Validate data before it enters the database. In this case, we need to check that
   * the value of the 'id' GET parameter is numeric
   */
   if ( is_numeric($id) == true){
    try{ // Check connection before executing the SQL query 
      /**
       * Setup the connection to the database This is usually called a database handle (dbh)
       */
      $dbh = new PDO('mysql:host=localhost;dbname=sql_injection_example', 'dbuser', 'dbpasswd');
 
      /**
       * We are going to use PDO::ERRMODE_EXCEPTION, to capture errors and write them to
       * a log file for later inspection instead of printing them to the screen.
       */
      $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
      /**
       * Before executing our SQL statement, we need to prepare it by 'binding' parameters.
       * We will bind our validated user input (in this case, it's the value of $id) to our
       * SQL statement before sending it to the database server.
       *
       * This fixes the SQL injection vulnerability.
       */
      $q = "SELECT username 
          FROM users
          WHERE id = :id";
      // Prepare the SQL query
      $sth = $dbh->prepare($q);
      // Bind parameters to statement variables
      $sth->bindParam(':id', $id);
      // Execute statement
      $sth->execute();
      // Set fetch mode to FETCH_ASSOC to return an array indexed by column name
      $sth->setFetchMode(PDO::FETCH_ASSOC);
      // Fetch result
      $result = $sth->fetchColumn();
      /**
       * HTML encode our result using htmlentities() to prevent stored XSS and print the
       * result to the page
       */
      print( htmlentities($result) );
 
      //Close the connection to the database
      $dbh = null;
    }
    catch(PDOException $e){
      /**
       * You can log PDO exceptions to PHP's system logger, using the Operating System's
       * system logging mechanism
       *
       * For more logging options visit http://php.net/manual/en/function.error-log.php
       */
      error_log('PDOException - ' . $e->getMessage(), 0);
      /**
       * Stop executing, return an 'Internal Server Error' HTTP status code (500),
       * and display an error
       */
      http_response_code(500);
      die('Error establishing connection with database');
    }
   } else{
    /**
     * If the value of the 'id' GET parameter is not numeric, stop executing, return
     * a 'Bad request' HTTP status code (400), and display an error
     */
    http_response_code(400);
    die('Error processing bad or malformed request');
   }
}

Y se debería usar en las sentencias SQL el parámetro LIMIT 1.

Recuerda deshabilitar las "emulated prepared statements"

Código

$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);

Recuerda que a partir de PHP 5.5.0 la función mysql_real_escape_string ya no existen y se debe usar la función :

mysqli::escape_string

Tienes más ejemplos con SMF 2.1 (BETA) que ya usa bcrypt para cifrar las contraseñas.

http://php.net/manual/es/security.database.sql-injection.php
https://www.owasp.org/index.php/SQL_Injection_Prevention_Cheat_Sheet

Hashes con salt

Los hashes con salt, son como los hashes de toda la vida pero con unplus de seguridad. En este caso el truco está en la salt que se le agrega. Salt es un número de dígitos aleatorios que se le agrega al hash ya sea al principio o al final. Con lo que los hashes ya no son los normales y por ende no figurarán en una tabla haciendo más dificil crackearlos. Ya que se deberá probar no solo con cada hash, sino tambien con cada salt y sus combinaciones.

Las funciones de hash más conocidas y utilizadas eran MD5 y SHA-1, pero dado que MD5 y SHA-1 han sido comprometidas, actualmente se recomienda el uso de nuevas funciones como son SHA-2 y Bcrypt.

El hecho de que los hashes sin salt no se combinaran con un valor "único" (salt) para que cada cuenta, hace que el proceso de crackeo sea mucho más rápido ya que requiere menos cálculo.

Gracias al "salt", garantiza que cada hash almacenado es único, incluso si dos usuarios eligen la misma contraseña de acceso, cada uno de hash en una tabla comprometida debe ser crackeada por separado.

La nueva API para codificar contraseñas de PHP 5.5

Internamente la API utiliza la función crypt() y está disponible desde la versión 5.5.0 de PHP. Si utilizas una versión anterior de PHP, siempre que sea igual o superior a 5.3.7, existe una librería con las mismas funcionalidades que la nueva API: github.com/ircmaxell/password_compat.

La función más importante de la nueva API es password_hash(), que codifica la contraseña que le pases con el algoritmo indicado

El primer argumento de la función es la contraseña original sin codificar y el segundo argumento debe ser una de las dos siguientes constantes

- PASSWORD_DEFAULT, codifica la contraseña utilizando el algoritmo bcrypt y el resultado es una cadena de 60 caracteres de longitud, cuyos primeros caracteres son $2y$10$. El algoritmo utilizado y la longitud de la contraseña codificada cambiarán en las próximas versiones de PHP, cuando se añadan algoritmos todavía más seguros. Si guardas las contraseñas en una base de datos, la recomendación es que reserves 255 caracteres para ello y no los 60 que se pueden utilizar actualmente.
- PASSWORD_BCRYPT, a pesar de su nombre, codifica la contraseña utilizando el algoritmo CRYPT_BLOWFISH. Al igual que en el caso anterior, la contraseña codificada ocupa 60 caracteres en total, siendo los primeros caracteres $2y$.

El tiempo empleado en codificar una contraseña se denomina "coste" y se puede configurar mediante el tercer argumento opcional de la función password_hash(). El coste por defecto es 10 (por eso el prefijo de las contraseñas anteriores es $2y$10$) y su valor debe estar comprendido entre 04 y 31.

http://php.net/manual/es/function.password-hash.php