Home / Questions / 96997
Accepted
J. Mick
Asked: 2020-08-24 15:37:35 +0800 CST 2020-08-24 15:37:35 +0800 CST

How to create a secure login system with php & mysqli?

  • 772

Secure system access analyzes of different Google Payoneer platforms among other financial platforms.

In the following analyzes I found these characteristics:

  • On the first failed attempt it shows the captcha code.
  • After 5 attempts the user's account is blocked for 15 minutes.
  • When you have access whether or not the fault history exists, you must answer a security question to continue.
  • Does not allow double logging.

Other References: create secure login script

I have managed to fix my old code.

Note: Please edit my question to avoid possible duplicate question.

The corrections:

It ipwill continue to be blocked, it will not affect anything because being blocked ipwill only show the captcha code.

I have created a new fail_attempt table with the following columns: something like my idea.

id_fail_attempt   id_user   attempt   ip       datetime                 time
      1              1        5      ::1   2017-08-23 17:57:46   2017-08-23 18:12:46

The following table login_attemptslists the failed attempts of theip

  id         ip        attempts        datetime               
  1         ::1           2       2017-08-23 17:57:46

The boardusers

id   username   email   password   lastname  active
1     Hola      hola@    Hola        Hola      1

How can I insert in the table fail_attemptthe iduser, the failed attempts, the iptime in which the user will be blocked access and how to control the double login of the same user in the same system.

Full PHP code

How do I add new features and create a secure system?

login.php

<?php
session_start();
$message="";
$captcha = true;

//
$con =  @new mysqli('localhost', 'root', '', 'systemuser');

  if(count($_POST)>0 && isset($_POST["vcode"]) && $_POST["vcode"]!=$_SESSION["vcode"]) {
    $captcha = false;
    $message = "Los caracteres escritos no coinciden con la palabra de verificación. Inténtalo de nuevo.";
  }

  $ip = $_SERVER['REMOTE_ADDR'];

  //Bloqueamos la ip por un día
  $result = mysqli_query($con,"SELECT * FROM failed_login WHERE ip='$ip' AND date BETWEEN DATE_SUB( NOW() , INTERVAL 1 DAY ) AND NOW()");
  $row  = mysqli_fetch_assoc($result);
  //Obtenemos datos para comprar intentos y para resetear intentos por su ultimo fecha.
  $failed_login_attempt = mysqli_real_escape_string($con,$row['attempts']);
  //Liberamos memoria.
  mysqli_free_result($result);

  if(count($_POST)>0 && $captcha == true) {
    $username = mysqli_real_escape_string($con, $_POST["username"]);
    $password = mysqli_real_escape_string($con, $_POST["password"]);
    $username = htmlentities($username);
    $password = htmlentities($password);
    $save_passw = sha1($password);
    $sql = "SELECT * fROM users where username='$username' AND password='$save_passw' AND active='1' ";
    $query = mysqli_query($con, $sql);

    $rowU  = mysqli_fetch_assoc($query);
    $UsernamaDB = mysqli_real_escape_string($con, $rowU["username"]);
    $passwordDB = mysqli_real_escape_string($con, $rowU["password"]);

    if($failed_login_attempt <1) {
            //Si es su primer intento fallido, incluimos el primer registro en la BD
            $con->query("INSERT INTO failed_login (ip,attempts,date) VALUES ('$ip', 1, NOW())");
            } else {
                if($failed_login_attempt <2){
                //En caso de ya estar en la BD, sacamos el valor y agregamos +1
                $contador = $row['attempts'] + 1;
                $con->query("UPDATE failed_login SET attempts='$contador', date=NOW() WHERE ip = '$ip'");
            }
        }


        if (empty($_POST) === false) {
            $username = $_POST['username']; $password = $_POST['password'];
            if (empty($username) === true || empty($password) === true) {
                $message = "Es necesario introducir un nombre de usuario y contraseña";
             } elseif ($username != $UsernamaDB) {
                $message = "El 'Usuario' que has introducido no coincide. ";
             } elseif ($save_passw != $passwordDB) {
                $message = "Tu 'Contraseña' introducido no coincide. ";
             } elseif($save_passw == $passwordDB && $username == $UsernamaDB) {
                $_SESSION["id_user"] = 1;
                $con->query("DELETE FROM login_attempts WHERE ip = '$ip'");
             }
            }
        }
        if(isset($_SESSION["id_user"])) {
            header("Location:http://localhost/index.php");
        }
?>
<h1><?php if($message!="") { echo $message; } ?></h1>
<form name="frmUser" method="post" action="">
  <input type="text" name="username" placeholder="Usuario">
  <input type="password" name="password" placeholder="Contraseña">
  <!-- captcha-->
  <?php if (isset($failed_login_attempt) && $failed_login_attempt >= 1) { ?>
    <br><img src="image.php" id="phoca-captcha"/>
  <input name="vcode" type="text" placeholder="Codigo captcha">
   <?php } ?>
  <!-- fin-->
  <input type="submit" value="Iniciar sesión" id="button-login">
</form>
php

6 Answers

  1. Best Answer

    Desde mi punto de vista ante todo debes proteger su Base de datos ante posibles ataques de inyección, piensa, para que sirve crear un sistema de login avanzado si después uno podría modificar fácilmente su Base de datos. Para ello podrías usar mysqli::prepare o PDO.

    Si quieres saber más como evitar la inyección SQL, te dejo esta pregunta con grandes respuestas en SOes.

    En mi ejemplo utilizo mysqli::prepare, el principal y más esencial beneficio de las declaraciones preparadas es la eliminación de todos los peligros del formato manual.

    Otro factor importante es el almacenaje de contraseñas seguras. En mi ejemplo utilizo password_verify, para comprobar si la contraseña conciden, importante, cuando registras un nuevo usuario utiliza la función password_hash() para crear un hash de contraseña seguro (No utilice sha1 o md5, ya que son vulnerables).

    Mas información sobre Almacenamiento de contraseñas PHP y MYSQL en SOes.

    Ejemplo crear un hash de contraseña:

    $contrasena = password_hash($_POST['contrasena'], PASSWORD_BCRYPT);

    BCRYPT, siempre tendrá 60 caracteres.

    Ejemplo completo:

    Voy a poner un posible ejemplo a tus deseos.

    Desde mi punto de vista al primer intento mostrar el código captcha, podría ser incomodo, ya que un usuario se equivoca fácilmente en el primer intento, vamos a poner en el 3 intento, aunque este valor se podría modificar como uno desea en realidad.

    Compuse el sistema basándome en los siguientes puntos (probado en localhost):

    • 3 intento, mostramos el código captcha y incrementamos.
    • 5 intento desactivamos el usuario durante 15min.
    • Intento 8 fallido en login_Attempts, se bloquea el login durante 1 día por IP.
    • En el intento 10, inactivamos el usuario hasta contactar con el administrador.
    • En caso introducir datos no validos inserta un intento fallido mediante su IP.
    • Inicia sesión mediante usuario y correo electrónico.
    • Seguridad en la Base de datos mediante sentencias preparadas.
    • password_hash, un hash de contraseña usando un algoritmo de hash fuerte de único sentido.

    Lo del doble logueo, personalmente no lo veo cómodo para los usuarios, siempre hay que mirar la comodidad del usuario y en ocasiones depende la aplicación es más cómodo trabajar con dos sesiones abiertas en diferentes ordenadores, piensa que si uno realmente quiere podría también fácilmente, grabar la pantalla de su aplicación y dárselo a terceros XD.

    Base de datos

    CREATE TABLE `fail_attempt` (
  `id_fail_attempt` int(11) UNSIGNED NOT NULL auto_increment primary key,
  `id_user` int(11) NOT NULL,
  `attempt` smallint(2) NOT NULL,
  `ip` varchar(100) COLLATE utf8_spanish_ci NOT NULL,
  `datetime` datetime NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

CREATE TABLE `login_attempts` (
  `id` int(11) UNSIGNED NOT NULL auto_increment primary key,
  `ip` varchar(100) NOT NULL,
  `attempts` smallint(2) NOT NULL,  
  `datetime` datetime NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

CREATE TABLE `users` (
  `id` int(11) UNSIGNED NOT NULL auto_increment primary key,
  `username` varchar(60) NOT NULL unique,
  `email` varchar(200) NOT NULL unique,
  `password` varchar(60) NOT NULL,
  `lastname` varchar(255) NOT NULL,
  `active` smallint(1) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

INSERT INTO `users` (`id`, `username`, `email`, `password`, `lastname`, `active`) VALUES
(1, 'Daniel', '[email protected]', '$2y$10$IptiWEQlWuIZHPvl7wVXfele2nKi1ics9EuTzeHv29MT7KUZfYTGa', 'Bulten', 1);

    Nota: Para hacer pruebas la contraseña con hash $2y$10$IptiWEQlWuIZHPvl7wVXfele2nKi1ics9EuTzeHv29MT7KUZfYTGa equivale a 123 y deberás modificar el correo electrónico al suyo si uno quiere.

    index.php

        <?php
      //Arrancamos sesión.
      session_start();
      //Comprobamos si esta iniciado sesión, caso contrario redirigimos al login.
      if (!isset($_SESSION['usuario'])) { header('Location:login.php'); }
    ?>
    <!DOCTYPE html>
    <html lang="es-ES">
    <body>
        Bienvenido <?php echo $_SESSION['usuario']; ?>  
        <a href="logout.php">Cerrar sesión</a>
    </body>
    </html>

    conexion.php (Estilo orientado a objetos).

        <?php
        //Configuración.
        $ServerName = "Localhost";
        $Username = "root";
        $PassWord = "root";
        $DataBase = "login_stackoverflow";    

        //Creamos conexión.
        $con = new mysqli($ServerName, $Username, $PassWord, $DataBase);

        //Comprobamos conexión.
        if ($con->connect_error) {
            exit("La conexión fallo: " . $con->connect_error);
        }

        //Caracteres UTF-8 para MySQL.
        if (!$con->set_charset("utf8")) {
            printf("Error cargando el conjunto de caracteres utf8: %s\n", $con->error);
            exit();
        }
    ?>

    login.php

    En mi ejemplo he usado en vede usuario el correo electrónico para iniciar sesión, ya que es unique como un usuario, aunque este valor es fácilmente modificable por usuario si uno desea. 

        <?php
    //Arrancamos sesión.
    session_start();

    //Caso estar iniciado sesión, redirigimos automatico al index.
    if (isset($_SESSION['usuario'])) { header('Location:index.php'); }
    //Conexión -> SQL
    require_once'conect.php';
    //Calculamos intentos fallidos por IP.
    $stmtIP = $con->prepare("SELECT attempts,datetime FROM login_attempts WHERE ip=?");
    //Ligar parametros marcadores.
    $stmtIP->bind_param("s",$addres);   
    //Obtenemos IP.
    $addres = $_SERVER['REMOTE_ADDR'];//Ip          
    //Ejecutar sentencia.
    $stmtIP->execute();             
    //Ligar variables de resultados BD.
    $stmtIP->bind_result($totalattempt,$getdatetime);
    //Obtenemos valores.
    $stmtIP->fetch();   
    //Cerrar sentencia.
    $stmtIP->close();   
    //Si supera más de 10 intentos, el IP quedara inactivo durante 1 dia.
    if ($totalattempt===8) {
        if (!isset($_SESSION['inactivo1day'])) {
            $_SESSION['inactivo1day'] = true;
        }
        //Reseteo intentos a 0 pasado 1 dia.
        if(strtotime($getdatetime) <= strtotime("-1 day")) { // -15 minutes podria ser -30minutes, -1hours, -day etc...
            //Sentencia.
            $stmtDel = $con->prepare("DELETE FROM login_attempts WHERE ip=?");
            //Ligar parametros marcadores.
            $stmtDel->bind_param("s",$addres);          
            $stmtDel->execute();
            //Cerrar sentencia.
            $stmtDel->close();
            //Eliminamos session inactivo
            unset($_SESSION['inactivo1day']);           
            //Redirigimos a login
            echo '<script>window.location="login.php"</script>';
        } else {
            //Mensaje cuenta desactivado durante 15min.
            $msg = "La IP ha quedado desactivado desde las {$getdatetime}, durante 1 dia., intentelo más tarde.";
        }           
    }
?>
<!DOCTYPE html>
<html lang="es-ES">
<head>  
    <!-- Libreria jQuery. -->       
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>  

    <meta charset="utf-8" /><!-- Character encoding. -->
    <script>
        $(document).ready(function() {
            //Formulario login.
            $(document).on('submit', '#login-form', function() {  
                //Data formulario    
                var data = $(this).serialize();                 
                $.ajax({        
                    type : 'POST',
                    url  : 'login_control.php',
                    data : data,
                    success :  function(data) {            
                        $("#result-login").html(data);  
                    }
                });             
                return false;    
            });         
        });
    </script>
</head>
<body>  
    <?php   
    if (!isset($_SESSION['inactivo1day'])) {            
        //En caso estar activado la sesión del captcha, se ativa el formulario captcha.         
    ?>      
            <h2>Por favor, introduce tu usuario / correo electrónico y contraseña para comenzar.</h2>               
            <form method="POST" id="login-form">                            
                <input type="text" name="usuario" placeholder="Usuario / Correo electrónico *" />
                <input type="password" name="password" placeholder="Contrase&ntilde;a *" /> 
                <?php
                if (isset($_SESSION['captchaValidar'])) {
                ?>
                <h2>Verifica los caracteres del 'Captcha' para continuar</h2>
                <img src='captcha_code.php' />              
                <input name='captcha_code' type='text' placeholder='Codigo captcha' />  
                <?php
                }
                ?>


                <button type="submit">Inicia sesión</button>                    
            </form>
            <br />
            <div id="result-login">
            <!-- Respuesta AJAX -->
                <?php if (isset($_SESSION['captchaValidar'])) {
                    echo $_SESSION['captchaValidar'];
                } ?>
            </div>      
        <?php

    } else {
        echo $msg;
    }
    ?>      
</body>
</html>

    login_control.php

    <?php
//Arrancamos sesión.
session_start();
//Zona region. 
date_default_timezone_set("Europe/Madrid");

//Reseteo de variables.
$msg = $usuario = $password = $captcha_code = NULL;

//Definido formulario y no es NULL.
if (isset($_POST) && !isset($_SESSION['captchaValidar'])) {

    //Inputs vacios.
    if (empty($_POST['usuario'])) {
        $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>El usuario / correo electrónico es obligatorio.";
    } elseif (empty($_POST['password'])) {
        $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>La contraseña es obligatorio.";
    } else {
        //Obtenemos datos inputs.
        $usuario = $_POST['usuario'] ?: '';
        $password = $_POST['password'] ?: '';
    }

    //Datos son verdadero.
    if ($usuario && $password) {        
        //Conexión -> SQL
        require_once'conect.php';
        //Obtenemos IP.
        $addres = $_SERVER['REMOTE_ADDR'];//Ip      
        //Comprobamos si existe usuario en la BD.
        //Sentencia.
        $stmt = $con->prepare("SELECT id,username,password FROM users WHERE username=? OR email=? LIMIT 1");
        //Ligar parametros marcadores, es decir, el valor ?, es decir email='$usuario' y las "s", estamos diciendo que $usuario es un string (cadena), si existen más, es importante su orden.
        $stmt->bind_param("ss",$usuario,$usuario);
        //Ejecutar sentencia.
        $stmt->execute();
        //Devuelve el número de filas de un conjunto de resultados de una sentencia.
        $stmt->store_result();
        //Comprobamos si existen registros
        if ($stmt->num_rows===1) {
            //Ligamos los datos desde la BD.
            $stmt->bind_result($id_user,$usernameBD,$passwordHASH);
            if ($stmt->fetch()) {

                //Comprobamos si el usuario esta desactivado  o tiene algun intento fallido, utilizamos el 'ID' del usuario.
                $stmtA = $con->prepare("SELECT attempt,datetime FROM fail_attempt WHERE id_user=? LIMIT 1");
                //Ligar parametros marcadores.
                $stmtA->bind_param("i",$id_user);               
                //Ejecutar sentencia.
                $stmtA->execute();
                //Devuelve el número de filas de un conjunto de resultados de una sentencia.
                $stmtA->store_result();
                //Con esta variable sabemos si necesitamos un insert o un update, ya que si encuentra  0 registros es insert y si es 1 va ser un update.
                $check_attempt = $stmtA->num_rows;
                //Ligar variables de resultados BD.
                $stmtA->bind_result($attempts,$getdatetime);
                //Obtenemos valores.
                $stmtA->fetch();    
                //Cerrar sentencia.
                $stmtA->close();

                //Mientras los intentos no supera a 11, continuamos con el login.
                if ($attempts < 11) {
                    //Si existen 5 intentos fallidos, no continua con el login, sino esta en modo desactivado durante x tiempo.
                    if ($attempts==5) {
                        //Reseteo intentos a 6 pasado 15min., para continuar y evitar en este bucle.
                        if(strtotime($getdatetime) <= strtotime("-1 minutes")) { // -15 minutes podria ser -30minutes, -1hours, -dia etc...
                            //Sentencia.
                            $stmtUp = $con->prepare("UPDATE fail_attempt SET attempt=?, ip=?  WHERE id_user=? LIMIT 1");
                            //Ligar parametros marcadores (???, es decir, $attempt='$int' and $ip='$addres' etc...).
                            $stmtUp->bind_param("isi", $int,$addres,$id_user);
                            //valores parametros marcadores.        
                            $int = 6;//Inilizamos en 6 intentos.
                            //Ejecutar sentencia.
                            $stmtUp->execute();
                            //Cerrar sentencia.
                            $stmtUp->close();
                            //Eliminamos session inactivo
                            unset($_SESSION['inactivo15']);
                            //Alerta.
                            echo '<script>window.alert("Pasaron 15min., su cuenta ha sido activado");</script>';
                            //Redirigimos a acceder
                            echo '<script>window.location="login.php"</script>';
                        } else {
                            //Mensaje cuenta desactivado durante 15min.
                            $msg = "Tu cuenta ha quedado desactivado desde las {$_SESSION['inactivo15']}, durante 15min., intentelo más tarde.";
                        }           
                    } else {
                        //En caso contrario continuamos con el login.

                        //Comprobamos password mediante la función password_verify.
                        if (password_verify($password, $passwordHASH)) {//Correcto, creamos la sesión del usuario.                                      
                            //Reseteamos intentos fallidos.
                            if ($check_attempt===1) {
                                //Reseteamos intentos en 0 para fail_attempt.
                                //Sentencia.
                                $stmtUp = $con->prepare("UPDATE fail_attempt SET attempt=?, ip=?, datetime=? WHERE id_user=? LIMIT 1");
                                //Ligar parametros marcadores.
                                $stmtUp->bind_param("issi",$reset_attempt,$addres,$datetime,$id_user);
                                //Creo valores marcadres.
                                $reset_attempt = 0;
                                //id_user ya lo hemos obtenido en la comprobacion si existe el usuario.
                                //Adrres ya es obtenido anteriormente.                      
                                $datetime = date('Y-m-d  H:i:s', time());
                                //Ejecutar sentencia.
                                $stmtUp->execute();
                                //Cerrar sentencia.
                                $stmtUp->close();

                                //Eleminas registro de login_attempts
                                //Sentencia.
                                $stmtDel = $con->prepare("DELETE FROM login_attempts WHERE ip=?");
                                //Ligar parametros marcadores.
                                $stmtDel->bind_param("s",$addres);          
                                $stmtDel->execute();
                                //Cerrar sentencia.
                                $stmtDel->close();
                            }
                            //Creamos sesión al usuario.
                            $_SESSION['usuario'] = $usernameBD;         
                            //Redirigimos a pagina protegida
                            echo '<script>window.location="index.php"</script>';

                        } else { //Contraseña incorrecto, añadimos intentos fallidos.                                   

                            //Actualizamos intentos usuario.
                            if ($check_attempt===0) {                       
                                //Insertar primer intento fallido.

                                //Sentencia.
                                $stmtIn = $con->prepare("INSERT INTO fail_attempt (id_user,attempt,ip,datetime) VALUES (?,?,?,?)");
                                //Ligar parametros marcadores.
                                $stmtIn->bind_param("iiss",$id_user,$attempts,$addres,$datetime);
                                //Creo valores marcadres.
                                //id_user ya lo hemos obtenido en la comprobacion si existe el usuario.
                                //Adrres ya es obtenido anteriormente.
                                $attempts = 1;
                                $datetime = date('Y-m-d  H:i:s', time());
                                //Ejecutar sentencia.
                                $stmtIn->execute();
                                //Cerrar sentencia.
                                $stmtIn->close();
                            } else {
                                //Actualizar, es decir, incrementar intento fallido.
                                //Sentencia.
                                $stmtUp = $con->prepare("UPDATE fail_attempt SET attempt=attempt+1, ip=?, datetime=? WHERE id_user=?");
                                //Ligar parametros marcadores.
                                $stmtUp->bind_param("ssi",$addres,$datetime,$id_user);
                                //Creo valores marcadres.
                                //id_user ya lo hemos obtenido en la comprobacion si existe el usuario.
                                //Adrres ya es obtenido anteriormente.                      
                                $datetime = date('Y-m-d  H:i:s', time());
                                //Ejecutar sentencia.
                                $stmtUp->execute();
                                //Cerrar sentencia.
                                $stmtUp->close();

                                //A no actualizar el navegador, incremento manualmente el attemp
                                $attempts = $attempts +1;       

                            }

                            //Comprobamos si ha excedido más de 8 intentos fallidos mediante su IP.                         
                            //Sentencia
                            $stmtIP = $con->prepare("SELECT attempts FROM login_attempts WHERE ip=?");
                            //Ligar parametros marcadores.
                            $stmtIP->bind_param("s",$addres);                               
                            //Ejecutar sentencia.
                            $stmtIP->execute();
                            //Devuelve el número de filas de un conjunto de resultados de una sentencia.
                            $stmtIP->store_result();
                            //Comprobamos si existen algun registro, para asi diferenciar si hacer un insert o update.  
                            $check_ip_attempts = $stmtIP->num_rows;         
                            //Ligar variables de resultados BD.
                            $stmtIP->bind_result($ip_attempts);
                            //Obtenemos valores.
                            $stmtIP->fetch();   
                            //Cerrar sentencia.
                            $stmtIP->close();               


                            //Insertar fallo a tabla login_attempts mediante su IP.
                            if ($check_ip_attempts===0) { 

                                //Sentencia.
                                $stmtIn = $con->prepare("INSERT INTO login_attempts (ip,attempts,datetime) VALUES (?,?,?)");
                                //Ligar parametros marcadores.
                                $stmtIn->bind_param("sis",$addres,$int,$datetime);
                                //Creo valores marcadres.                                   
                                //Adrres ya es obtenido anteriormente.                                  
                                $int = 1;
                                $datetime = date('Y-m-d  H:i:s', time());
                                //Ejecutar sentencia.
                                $stmtIn->execute();
                                //Cerrar sentencia.
                                $stmtIn->close();
                            } else { //Update fallo IP.
                                //Sentencia.
                                $stmtUp = $con->prepare("UPDATE login_attempts SET ip=?, attempts=attempts+1, datetime=? WHERE ip=?");
                                //Ligar parametros marcadores.
                                $stmtUp->bind_param("sss",$addres,$datetime,$addres);
                                //Creo valores marcadres.                               
                                //Adrres ya es obtenido anteriormente.                      
                                $datetime = date('Y-m-d  H:i:s', time());
                                //Ejecutar sentencia.
                                $stmtUp->execute();
                                //Cerrar sentencia.
                                $stmtUp->close();
                                //Incrementamos manualmente, a no actualizar navegador.
                                $ip_attempts = $ip_attempts+1;
                            }

                            //IP esta bloqueda.
                            if ($ip_attempts===8) {     
                                $_SESSION['inactivo1day'] = true;
                                //Redirigimos a acceder
                                echo '<script>window.location="login.php"</script>';        
                            }

                            //Mensajes contraseña fallidos.

                            //Primer fallo, mostramos el captcha.
                            if ($attempts<2) {
                                $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu contraseña es incorrecto, vuelva a intentarlo.";   
                            } elseif ($attempts ==3) {                              
                                //Arrancamos sesión del captcha.
                                $_SESSION['captchaValidar'] = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu contraseña es incorrecto, vuelva a intentarlo.<p>";
                                echo '<script>window.location="login.php"</script>';                            
                            } elseif ($attempts==4) {
                                $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu contraseña es incorrecto, te queda un intento más para desactivar su cuenta durante 15min.</p>";
                            } elseif ($attempts==5) {
                                $_SESSION['inactivo15'] = date("H:i:s");
                                $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu cuenta ha quedado desactivada desde las {$_SESSION['inactivo15']}, durante 15min., intentelo más tarde.</p>";
                            } elseif ($attempts <=9) {
                                $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu contraseña es incorrecto, vuelva a intentarlo.<p>";
                            } elseif ($attempts<=10) {
                                $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu contraseña es incorrecta, llevas 9 intentos fallidos, te queda un intento más, sino deberás ponerte en contacto con administración.</p>";
                            } else {
                                $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu cuenta ha quedado desactivada, por favor ponte en contacto con [email protected] para activar su cuenta de nuevo.</p>";
                            }                           
                        }
                    }                   
                } else {
                //Supera el maximo de intentos permitido, cuenta esta inactivo durante X tiempo.
                    $msg = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>Tu cuenta ha quedado desactivada, por favor ponte en contacto con [email protected] para activar su cuenta de nuevo.";                          
                }
            } $stmt->close();
        } else {
            //Cerrar sentencia.
            $stmt->close(); 

            //Comprobamos si ha excedido más de 8 intentos fallidos mediante su IP.                         
            //Sentencia
            $stmtIP = $con->prepare("SELECT attempts FROM login_attempts WHERE ip=?");
            //Ligar parametros marcadores.
            $stmtIP->bind_param("s",$addres);                               
            //Ejecutar sentencia.
            $stmtIP->execute();
            //Devuelve el número de filas de un conjunto de resultados de una sentencia.
            $stmtIP->store_result();
            //Comprobamos si existen algun registro, para asi diferenciar si hacer un insert o update.  
            $check_ip_attempts = $stmtIP->num_rows;         
            //Ligar variables de resultados BD.
            $stmtIP->bind_result($ip_attempts);
            //Obtenemos valores.
            $stmtIP->fetch();   
            //Cerrar sentencia.
            $stmtIP->close();


            //IP esta bloqueda.
            if ($ip_attempts===8) {     
                $_SESSION['inactivo1day'] = true;
                //Redirigimos a acceder
                echo '<script>window.location="login.php"</script>';        
            }

            if ($check_ip_attempts===0) { //Insert fallo IP.

                //Sentencia.
                $stmtIn = $con->prepare("INSERT INTO login_attempts (ip,attempts,datetime) VALUES (?,?,?)");
                //Ligar parametros marcadores.
                $stmtIn->bind_param("sis",$addres,$int,$datetime);
                //Creo valores marcadres.                                   
                //Adrres ya es obtenido anteriormente.                                  
                $int = 1;
                $datetime = date('Y-m-d  H:i:s', time());
                //Ejecutar sentencia.
                $stmtIn->execute();
                //Cerrar sentencia.
                $stmtIn->close();
            } else { //Update fallo IP.
                //Sentencia.
                $stmtUp = $con->prepare("UPDATE login_attempts SET ip=?, attempts=attempts+1, datetime=? WHERE ip=?");
                //Ligar parametros marcadores.
                $stmtUp->bind_param("sss",$addres,$datetime,$addres);
                //Creo valores marcadres.                               
                //Adrres ya es obtenido anteriormente.                      
                $datetime = date('Y-m-d  H:i:s', time());
                //Ejecutar sentencia.
                $stmtUp->execute();
                //Cerrar sentencia.
                $stmtUp->close();
            }           

            //Arrancamos sesión del captcha.
            $_SESSION['captchaValidar'] = "<p style='background-color:red; color:white; padding:1rem; margin-top:1rem; max-width:300px;'>El usuario / correo electrónico no existen.<p>";
            echo '<script>window.location="login.php"</script>';
        }
    }
} else {
    //Comprobamos que esten escrito correctamente los caracteres del captcha.
    if ($_POST["captcha_code"]!=$_SESSION["captcha_code"]) {                            
        $msg = "<div class='dangerB font1'>Los caracteres escritos no coinciden con la palabra de verificación. Inténtalo de nuevo.</div>";
    } else { //Caracteres coinciden.
        //Destruimos la sesión.             
        unset($_SESSION['captchaValidar']);
        //Redirigimos al login.
        echo '<script>window.location="login.php"</script>';
    }   
}
//Respuesta Ajax
echo $msg;
?>

    captcha_code.php

    Nota: deberas crear dos carpetas font/SpecialElite.ttf y img/captcha.png, dicha imagen o fuente pueden ser personalizados a gusto de cada uno.

    <?php
session_start();
$random_alpha = md5(rand());
$captcha_code = substr($random_alpha, 0, 6); // Numero total de caracters en el captcha

$_SESSION["captcha_code"] = $captcha_code;
$target_layer = imagecreatefrompng("img/captcha.png"); /// Fondo personalizado para el sistema de captcha.
$textColor = imagecolorallocate($target_layer, 71,171,118); // Color de la fuente
$lineColor = imagecolorallocate($target_layer, 255,255,255); // Color de las lineas del captcha
$imageInfo = getimagesize("img/captcha.png"); // fondo de la imagen

$linesToDraw = 40; // numero total de lineas en el captcha

for( $i = 10; $i < $linesToDraw; $i++ )  {      
    $xStart = mt_rand( 0, $imageInfo[ 0 ] );
    $xEnd = mt_rand( 0, $imageInfo[ 0 ] );    
    imageline($target_layer, $xStart, 0, $xEnd, $imageInfo[1], $lineColor );    
}

imagettftext($target_layer, 35, 2, 41, 50, $textColor, "font/SpecialElite.ttf", $captcha_code );

header("Content-type: image/png");
imagepng($target_layer);
imagedestroy($target_layer); 
?>

    logout.php

    <?php
    //Activar sesión.
    session_start();
    //Remover sesión.
    session_unset();
    //Destruir sesión.
    session_destroy();
    //Redirigimos
    header('location: login.php');
?>

    Estructura para hacer pruebas facilmente en localhost:

    RAIZ
    font / SpecialElite.ttf (font)
    img / captcha.png (dimensiones: 250x60 pixeles)
    captcha_code.php
    conect.php
    index.php
    login.php
    login_control.php
    logout.php

    • 10

  2. What you should do is

    1. In the table login_attempts, change the attribute ipto user_idor username(in the case that it is not repeated) to establish the relationship by user instead of by IP.
    2. Change the query in the query $result5to obtain the data for the user_idone that is making the connection.
    3. If the lock must be forever, you have to remove it from login_attemptsthe attribute timeor assign it at a very distant date with the lock.
    4. $messageit should show the contact admin message when it hits 5 errors before you could show the number of times it failed.
    • 0

  3. I think that the best way to approach this type of problem is by using a class to be able to have a minimum abstraction.

    I will show you a basic example trying not to complicate it too much so that you can easily understand the code, do it quickly so it has some shortcomings.

    The class allows us to:

    • Validate a user, allowing a number of attempts in a given time (by default 5 attempts in 1 minute).
    • Block the user permanently if the maximum limit is exceeded (by default 10 attempts in 1 minute).
    • Retrieve user data
    • Keep a record of logins made.
    • Know the IP.

    The denial of access and blocking of access is performed on the user without taking into account the IP, this does not mean that a method cannot be implemented for this purpose.

    We should have the following tables in our database:

    users

    CREATE TABLE `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `password` varchar(255) NOT NULL,
  `login_success` datetime DEFAULT NULL,
  `status` tinyint(2) NOT NULL DEFAULT '1',
  PRIMARY KEY (`id`),
  UNIQUE KEY `username` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4

    login_log

    CREATE TABLE `login_log` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) NOT NULL,
  `fecha` datetime NOT NULL,
  `msg` varchar(255) NOT NULL,
  `ip` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=112 DEFAULT CHARSET=utf8mb4

    We create a basic class for the connection to the database

    Class Connection

    class Conexion
{
    private $servidor ="localhost";
    private $usuario ="user";
    private $contrasena ="pass";
    private $nombre_bd ="login";
    public $link;

    public function __construct()
    {
        $this->link = new mysqli($this->servidor, $this->usuario, $this->contrasena, $this->nombre_bd) or die("Error con la base de datos.");

        if ($this->link->connect_errno) {
            printf("Connect failed: %s\n", $mysqli->connect_error);
            exit;
        }
        if (!$mysqli->set_charset("utf8")) {
            printf("Error cargando el conjunto de caracteres utf8: %s\n", $mysqli->error);
            exit;
        }

    }
}

    LoginController class

    // Declaramos la clase y extendemos de Conexion
class LoginController extends Conexion
{
    // Datos recuperados del usuario, puede ser util para crear las sesiones
    public $dataUser = null;
    // Nombre de usuario a validar
    public $username;
    // Contraseña a validar
    public $password;
    // IP conexion user
    public $ip;
    // Numero de intentos antes de denegar el acceso
    public $attempt = 5;
    // Numero de intentos antes de bloquear al usuario
    public $attemptBan = 10;
    // Tiempo para los intentos en segundos
    public $attempt_time = 60;
    // Fecha actual
    public $now;
    // Fecha actual menos $attempt_time
    public $nowDiff;
    // mensaje del resultado del acceso
    public $msg;
    // salt para la encriptacion 
    protected $salt = '$6$rounds=5000$estoesunstringdesalt$';

    public function __construct()
    {
        /* Inicializamos la conexion a la base de datos */
        parent::__construct();

        /* Establecemos la IP */
        $this->ip = $_SERVER['REMOTE_ADDR'];

        $time = new DateTime();
        // Establecemos la fecha actual
        $this->now = $time->format('Y-m-d H:i:s');

        $time->modify('-'.$this->attempt_time.' seconds');
        // Establecemos la fecha actual menos (intentos * tiempo por intento)
        $this->nowDiff = $time->format('Y-m-d H:i:s');
    }

    // Esta funcion se encargara de hacer las validaciones
    public function validate($username, $password)
    {
        // Establecemos usuario y contraseña
        $this->username = $username;
        $this->password = $password;
        // Buscamos el usuario en la base de datos
        $sql = 'SELECT id, username, password, login_success, status FROM users WHERE username = ? LIMIT 1';
        $stmt = $this->link->prepare($sql);
        $stmt->bind_param('s', $this->username);
        $stmt->execute();
        $resultado = $stmt->get_result();
        // Comprobamos si se ha encontrado el usuario
        if ($resultado->num_rows)
        {
            $row = $resultado->fetch_assoc();
            // Guardamos los datos del usuario
            $this->dataUser = $row;
            // Comprobamos si esta desactivado
            if (1 != $row['status'])
            {
                // Si esta desactivado registramos en el los el intento y retornanomos false
                $this->loginLog($this->username, $this->now, 'Usuario bloqueado' );
                return false;                    
            }
            // Comprobamos de si la contraseña es correcta
            if( hash_equals( $row['password'], crypt($this->password, $this->salt) ) )
            {
                // Actualizamos el ultimo inicio de sesion correcto
                $this->loginSuccess($row['id']);
                // Comprobamos los intentos
                return $this->attempt();
            }
            else
            {
                // Si la contraseña no es correcta registramos el log y retornamos false
                $this->loginLog($this->username, $this->now, 'Error de password' );
                return false;
            }
        }
        else
        {
            // Si no se encontro el usuario registramos log y retornamos false
            $this->loginLog($this->username, $this->now, 'Error de usuario' );
            return false;
        }
    }

    // Funcion para comprobar los pasos
    protected function attempt()
    {
        // Recuperamos del log los intentos desde la fecha nowDiff
        $sql = 'SELECT count(*) n FROM login_log WHERE username = ? AND fecha > ?';
        $stmt = $this->link->prepare($sql);
        $stmt->bind_param('ss', $this->username, $this->nowDiff);
        $stmt->execute();
        $resultado = $stmt->get_result();
        // Comprobamos si se recuperaron registros
        if ($resultado->num_rows)
        {
            $rows = $resultado->fetch_assoc();
            // Comprobamos si el numero de registros es menor al numero de intentos
            if ($this->attempt >= $rows['n']) 
            {
                // Si es menor a los intentos registramos el acceso y devolvemos true
                $this->loginLog($this->username, $this->now, 'success' );
                return true;
            }
            // Comprobamos si es mayor a attemptBan
            elseif ($this->attemptBan < $rows['n'])
            {
                // registramos el acceso
                $this->loginLog($this->username, $this->now, 'Se ha baneado el usuario' );
                // Bloqueamos el usuario
                $this->userBan();
                // Debolvemos false
                return false;
            }
            else
            {
                // En cualquier otro caso registramos el acceso y retornamos false
                $this->loginLog($this->username, $this->now, 'Login bloqueado durante '.$this->attempt_time );
                return false;
            }

        }
        // Se nunca se a logeado registramos el acceso
        $this->loginLog($this->username, $this->now, 'success' );
        // Devolvemos true
        return true;
    }

    // Esta funcion se encargara de registrar los accesos
    protected function loginLog($username, $fecha, $msg)
    {
        // registramos el acceso a la base de datos
        $sql = 'INSERT INTO login_log (username, fecha, msg, ip) VALUES ( ?, ?, ?, ? ); ';
        $stmt = $this->link->prepare($sql);
        $stmt->bind_param('ssss', $username, $fecha, $msg, $this->ip);
        $stmt->execute();
        // Guardamos el mensaje
        $this->msg = $msg;
        return true;
    }

    // Esta funcion se encarga de actualizar el ultimo acceso
    protected function loginSuccess(int $idUser)
    {
        $sql = 'UPDATE users SET login_success = NOW() WHERE id = '.$idUser;
        $stmt = $this->link->query($sql);
        return true;
    }

    // Esta funcion se encarga de bloquear el usuario
    protected function userBan()
    {
        $sql = 'UPDATE users SET status = 0 WHERE username = ? ;';
        $stmt = $this->link->prepare($sql);
        $stmt->bind_param('s', $this->username);
        $stmt->execute();
    }


    /* Esta funcion solo la pongo a modo ilustrativo para crear un usuario en la bd */
    public function createUser($username, $password)
    {
        $has = crypt($password, $this->salt);
        $sql = 'INSERT INTO users ( username, password ) VALUES ( ?, ? ); ';
        $stmt = $this->link->prepare($sql);
        $stmt->bind_param('ss', $username, $has);
        $stmt->execute();
    }

    public function __destruct()
    {
        // Cerrramos la conexion
        $this->link->close();
    }
}

    Basic use of the class

    // Inicializamos la clase 
$auth = new LoginController();

// Validamos el usuario
if( $auth->validate('nombre_usuario_a_validar', 'contraseña_a_validar') )
{
    // Login OK
    echo '<pre>';
    print_r($auth->dataUser);
    echo '</pre>';
    echo $auth->msg;
}
else
{
    // Login KO
    echo $auth->msg;
}

    This class, although functional, is an example class so no errors are caught, nor is it taken into account that queries may fail. The results of queries are also not released, nor is the visibility of methods and properties taken into account. Among other things.

    • 0

  4. Hello, I will tell you how we have secured a system that manages premium video content and prevents double use as well as illegitimate use.

    Boards: 

    Usuarios
ID - Usuario - Email - Password - NumSession

    This table records the different users, registration date, password modification date, etc.

    Fails
ID - Usuario(nullable) - Email - Password - IP - UserAgent - SessionId - CloudflareID - DateTime

    We use this table to manage the erroneous login failures, we save the data that you have sent in the form, we associate a user if possible, in our case we use Cloudflare that provides us with a rich user ID that is quite successful, and not very avoidable, hehe, and to prevent incorrect logins we use this data, as well as the user agent and the session id instead of the ip. We use escalated validation, that is, we reduce factors to block the user depending on the number of attempts.

    Sessions
ID - Usuario - Inicio - Fin - CloudflareID - IP - UserAgent

    In this table we store the different sessions as well as their status, we call the session the moment the user logs in and it is ok, first we verify that there are no active sessions, comparing the End date to see if it is closed or not. In our case we have an option to buy a subscription with access to up to 5 devices, in this case the maximum number of sessions is 5.

    Within our platform, as it is a streaming retransmission, continuous requests are made, so that sessions with more than 120 seconds from the current moment are understood as closed.

    Other active protection systems In
    addition to the above, we have several active security systems to prevent unauthorized use or account sharing.

    Seguimiento de dispositivos.
    Utilizando el user Agent y el proveedor de la IP (Movistar, Orange, Vodafone, etc) hemos creado una tabla devices que les asignamos a un usuario, de tal manera que cuando accede desde un dispositivo que anteriormente no ha accedido solicitamos una doble verificación del usuario. Otra funcionalidad es que no pueda acceder desde otros dispositivos. El asunto del proveedor de servicios aún está en pruebas pero apunta maneras XD Aquí también se ha planteado utilizar la resolución dela pantalla, ya que habitualmente vemos las series y películas en pantalla completa, pero aún estamos en pruebas.

    Doble factor de autentificación
    Para cosas "raras" cambio de password, cambio de email, nuevos dispositivos, ip de comunidad distinta, etc solicitamos una doble autentificación, bien por email, authy, SMS, llamada, etc.

    Uso de WAF
    No tengo acciones de Cloudflare, aunque me gustaría, pero en mi concepto de ciberseguridad es fundamental.

    Por último te diría que la ciberseguridad hoy en día es fundamental en cualquier proyecto, por lo que debería ser gestionada y supervisada por una empresa especializada en este ámbito.

    • 0

  5. He realizado ajustes a tu código implementado lo que solicitas:

    • Al primer intento fallido muestra el código captcha.
    • A los 5 intentos la cuenta del usuario es bloqueada por 15 minutos.
    • No permite un doble logueo.
    • A los 8 intentos fallidos la IP es bloqueada por 1 Dia.

    La cantidad de intentos esta en una variable así podrás ajustarlo. Si no quieres que bloquee la IP podrias ponerle a la variable $intentosIP = 1000 por ejemplo, o ajustar el codigo :)

    Me gustaría aclarar que para realizar esto hay muchas formas, frameworks, librerías, patrones, etc. Me he limitado a seguir el estilo de tu código y he trabajado sobre ello, pero queda la recomendación de usar por ejemplo Programación Orientada a Objetos, evitar Inyección SQL, etc.

    Base de Datos Se mantuvo la Base de Datos publicada, solo a la tabla users se le agrego el campo logindatetime de tipo datetime que servira para validar el doble logueo.

    fail_attempt 

    id_fail_attempt   id_user   attempt   ip       datetime                 time
      1              1        5      ::1   2017-08-23 17:57:46   2017-08-23 18:12:46

    login_attempts

      id         ip        attempts        datetime               
  1         ::1           2       2017-08-23 17:57:46

    users

    id   username   email                    password                   lastname  active  logindatetime
1     Hola      hola@    4e46dc0969e6621f2d61d2228e3cd91b75cd9edc     Hola      1         NULL

    "4e46dc0969e6621f2d61d2228e3cd91b75cd9edc" es "Hola" en sha1, al loguerase solo escribir "Hola", PHP lo convertira en sha1 para la comparacion con BD.

    Cada vez que se agregue un usuario usar la funcion sha1, ejemplo:

    insert into users (id, username, email, password, lastname, active) values (2,'juliocpiro',sha1('12345'),'jcsar',1);

    Doble logueo

    Usara el campo logindatetime de la tabla users. Cuando el usuario se loguea es redireccionado a la pagina index.php (codigo original).

    En la pagina index.php se invoca un ajax que actualiza el campo logindatetime para saber que el usuario ha sido logueado satisfactoriamente. Tambien hay un boton Cerrar Sesion que limpia el campo logindatetime, de modo que cuando el campo esta NULL sabemos que el usuario ya no esta logueado.

    Para el caso que el usuario cierre el navegador sin antes usar el boton Cerrar Sesion, ha considerado invocar al ajax cada 1 minuto. De modo que si logindatetime tiene una hora de mas de 2 minutos se entenderia que fue una sesion abandonada y se consideraria como que el usuario ya no esta logueado.

    Solucion

    Para correr este codigo, los archivos den estar dentro de una carpeta login

    introducir la descripción de la imagen aquí

    captcha.php Para generar dinamicamente la imagen captcha

    <?php
session_start();
function obtenerTexto($longitud) {
    $patron = "1234567890abcdefghijklmnopqrstuvwxyz";$texto=null;
    for($i=0;$i<$longitud;$i++) {$texto .= $patron{rand(0,35)};}
    return $texto;
}
$_SESSION['vcode'] = obtenerTexto(5);
$imgcaptcha = imagecreatefromgif("fondocaptcha.gif");
$color = imagecolorallocate($imgcaptcha, 0, 0, 0);
imagestring($imgcaptcha, 5, 16, 7, $_SESSION['vcode'], $color);

header("Content-type: image/gif");
imagegif($imgcaptcha);
?>

    requiere de esta imagen introducir la descripción de la imagen aquí

    login.php Codigo publicado reajustado

    <?php
session_start();
$message="";
$captcha = true;
//indicador usuario logueado
$logueado = false;
//Nro intentos permitidos para IP
$intentosIP = 8;
//Nro intentos permitidos para Usuario
$intentosU = 5;

if(count($_POST)>0 && isset($_POST["vcode"]) && $_POST["vcode"]!=$_SESSION["vcode"]) {
    $captcha = false;
    $message = "Los caracteres escritos no coinciden con la palabra de verificación. Inténtalo de nuevo.";
}else{
    unset($_SESSION['id_user']);
}

$ip = $_SERVER['REMOTE_ADDR'];

$con =  @new mysqli('localhost', 'root', '', 'systemuser');
//Bloqueamos la ip por un día
$result = mysqli_query($con,"SELECT * FROM login_attempts WHERE ip='$ip' AND datetime BETWEEN DATE_SUB( NOW() , INTERVAL 1 DAY ) AND NOW()");
$row  = mysqli_fetch_assoc($result);
//Obtenemos datos para comprar intentos y para resetear intentos por su ultimo fecha.
$failed_login_attempt=0;
if($row!=null){
    $failed_login_attempt = mysqli_real_escape_string($con,$row['attempts']);
}
//Liberamos memoria.
mysqli_free_result($result);

if(count($_POST)>0 && $captcha == true) {
    $username = mysqli_real_escape_string($con, $_POST["username"]);
    $password = mysqli_real_escape_string($con, $_POST["password"]);
    $username = htmlentities($username);
    $password = htmlentities($password);
    $save_passw = sha1($password);

    //Buscar usuario ingresado - INICIO
    $sql = "SELECT *, CASE WHEN logindatetime BETWEEN DATE_SUB( NOW() , INTERVAL 2 MINUTE ) AND NOW() THEN '1' ELSE '0' END as logueado FROM users where username='$username' AND active='1' ";
    $query = mysqli_query($con, $sql);
    $rowU  = mysqli_fetch_assoc($query);
    $UsernamaDB = mysqli_real_escape_string($con, $rowU["username"]);
    $passwordDB = mysqli_real_escape_string($con, $rowU["password"]);
    //Buscar usuario ingresado - FIN

    //registra intentos de login segun IP - INICIO
    //////////////////////////////////////////////
    if($row==null){
        //Si es su primer intento fallido, incluimos el primer registro en la BD
        $con->query("INSERT INTO login_attempts (ip,attempts,datetime) VALUES ('$ip', 1, NOW())");
    }else{
        //se actualiza mientras el nro de intentos este abierto, para evitar bug con calculo del dia bloqueado
        if($row['attempts']<$intentosIP){
            $contador = $row['attempts'] + 1;
            $con->query("UPDATE login_attempts SET attempts='$contador', datetime=NOW() WHERE ip = '$ip'");
        }       
    }
    //registra intentos de login segun IP - FIN

    //VALIDANDO DOBLE LOGUEO
    if($save_passw == $passwordDB && $username == $UsernamaDB && $rowU['logindatetime']!=null && $rowU['logueado']=='1') {
        $logueado = true;
    }else{  
        //registra intentos segun usuario - INICIO
        ////////////////////////////////////////
        $attempU = 0;
        if($UsernamaDB!= null && $UsernamaDB!=''){
            $id_user = $rowU['id'];
            $query = mysqli_query($con, "SELECT * FROM fail_attempt WHERE id_user ='$id_user' AND datetime BETWEEN DATE_SUB( NOW() , INTERVAL 15 MINUTE ) AND NOW() ");
            $rowFA  = mysqli_fetch_assoc($query);
            if($rowFA==null){
                $con->query("INSERT INTO fail_attempt (id_user, attempt, ip, datetime) VALUES ('$id_user', 1, '$ip', NOW())");
            }else{
                $attempU =$rowFA['attempt']+1;
                //se actualiza mientras el nro de intentos este abierto, para evitar bug con calculo de 15 minutos bloqueado
                if($rowFA['attempt']<$intentosU){
                    $con->query("UPDATE fail_attempt SET attempt='$attempU', ip = '$ip', datetime=NOW() where id_user ='$id_user' ");
                }
            }
        }
        //registra intentos segun usuario - FIN     
    }

    //validando Usuario y Contraseña - INICIO
    $username = $_POST['username']; $password = $_POST['password'];
    if (empty($username) || empty($password)) {
        $message = "Es necesario introducir un nombre de usuario y contraseña";
    } elseif($failed_login_attempt>=$intentosIP){
        $message = "'IP' bloqueada por 1 dia, contando desde las ".$row['datetime'];
    } elseif($logueado){
        $message = "'Usuario' ya se encuentra logueado.";
    } elseif($attempU>=$intentosU){
        $message = "'Usuario' bloqueado por 15 minutos, contando desde las ".$rowFA['datetime'];
    } elseif ($username != $UsernamaDB) {
        $message = "El 'Usuario' que has introducido no coincide. ";
    } elseif ($save_passw != $passwordDB) {
        $message = "Tu 'Contraseña' introducido no coincide. ";
    } elseif($save_passw == $passwordDB && $username == $UsernamaDB) {
        $_SESSION["id_user"] = $rowU['id'];
        $con->query("DELETE FROM login_attempts WHERE ip = '$ip'");
        $con->query("DELETE FROM fail_attempt WHERE id_user ='$id_user'");
    }
    //validando Usuario y Contraseña - FIN

    if(isset($_SESSION["id_user"])) {
        header("Location:http://localhost/login/index.php");
    }
}
?>
<h1><?php if($message!="") { echo $message; } ?></h1>
<form name="frmUser" method="post" action="">
  <input type="text" name="username" placeholder="Usuario">
  <input type="password" name="password" placeholder="Contraseña">
  <!-- captcha-->
  <?php if ( (isset($failed_login_attempt) && $failed_login_attempt >= 1) || (count($_POST)>0) ) { ?>
    <img src="captcha.php" id="phoca-captcha"/>
    <input name="vcode" type="text" placeholder="Codigo captcha">
   <?php } ?>
  <!-- fin-->
  <input type="submit" value="Iniciar sesión" id="button-login">
</form>

    index.php Pagina de Bienvenida, luego del login.

    <?php
    session_start();
    if(!isset($_SESSION["id_user"])) {
        header("Location:http://localhost/login/login.php");
    }
?>
<!doctype html>
<html lang="en">
<head>
  <script src="https://code.jquery.com/jquery-1.10.2.js"></script>
  <script>
    $(function(){
        //al ingresar actualiza campo "logindatetime"
        refrescalogin();
        //invocar cada 1 minuto
        setInterval(refrescalogin,60000);
    });
    function refrescalogin(){
        $.ajax({url: "logueado.php?cerrar=0", success: function(result){console.log(result);}});
    }
  </script>
</head>
<style>
    .boton{text-align: right;background: #ccc;display: inline-block;right: 10px;position: absolute;padding: 5px;box-shadow:0px -5px 3px #bbb inset,-5px 0px 3px #bbb inset,5px 0px 3px #aaa inset,0px 5px 3px #aaa inset;   }
</style>
<body>
    <div class="boton"><a href="logueado.php?cerrar=1">Cerrar Sesion</a></div>
    Bienvenido
</body>
</html>

    logueado.php Actualizara el campo logindatetime y cerrara sesion

    <?php
session_start();
$id_user = $_SESSION["id_user"];
$con =  @new mysqli('localhost', 'root', '', 'systemuser');
$logindatetime=($_GET['cerrar']=='1')?"NULL":"NOW()";
$sql="UPDATE users SET logindatetime=$logindatetime WHERE id = $id_user";
$con->query($sql);

if($_GET['cerrar']=='1'){
    unset($_SESSION['id_user']);
    header("Location:http://localhost/login/login.php");
}else{
    echo("datos refrescados");
}
?>

    Captura

    introducir la descripción de la imagen aquí

    Podrían surgir mas casos de uso o validaciones que ajustarían mas el código. Si tienes dudas, conversamos por lo comentarios.

    • 0

  6. Actually blocking the IP is not a good idea, since 99% of users have dynamic IPs and only restarting the router would allow me to get a new IP.

    One option would be to carry out a more specific control, but the implementation requires analysis since, as in any system; the more complex, the more error-prone and more expensive to maintain.

    USER STATUS

    When performing the logon the user could save an online state in the base and while the state is present no one else can connect to the system. It refreshes after a few minutes without user interaction on the site or when logoffing.

    ACTIVITY ANALYSIS

    You could implement an activity table for each user, in which the IP's and GEOlocation from which they connect to the system are registered, from it you would have to generate reports and analyze or buy a system that performs this type of analysis.

    LOGIN WITH DOUBLE AUTHENTICATION

    There are several ways to implement it, for example a Token with a series of numbers which you must enter, these can be sent through an email message, APP or by SMS.

    SOCIAL ENGINEERING

    Link access to your platform through a Facebook/Instagram/Linekdin/etc account. This type of connection with social networks reduces the possibility of sharing accounts.

    Depending on the criticality and scope of your system, these security projects are no longer optional to protect both the company and the customer.

    • -2