用户多次输错密码后的登录限制策略

已于 2025-01-15 08:52:02 修改
阅读量791 收藏 19
点赞数 21
文章标签： java spring boot redis
于 2025-01-15 08:47:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73355421/article/details/145152286
版权

在网络应用中，保障账户安全是一个重要议题。当用户多次输入错误密码后，系统需要采取一定的限制措施以防止暴力破解等恶意攻击。本文将探讨几种实现用户登录限制的策略，包括使用 Redis 和不使用 Redis 的方法，以及其他可能的方案。

引言

用户登录时多次输错密码是一个常见的安全问题。为了保护用户账户不被恶意破解，系统需要在用户连续输错密码达到一定次数后，限制该用户的登录尝试。本文将详细介绍几种实现这一功能的方法。

使用 Redis 实现登录限制

Redis 是一个高性能的键值存储系统，常用于实现缓存和会话存储。利用 Redis，我们可以轻松实现对用户登录尝试次数的跟踪和限制。

实现步骤

  1. 记录尝试次数：为每个 IP 地址创建一个键，记录其登录尝试次数。

  2. 设置过期时间：为该键设置一个过期时间，例如 10 分钟，表示在这段时间内禁止登录。

  3. 检查和更新尝试次数：

    • 用户尝试登录时，检查对应的 Redis 键是否存在。

    • 如果不存在，说明是第一次尝试，直接验证用户名和密码。

    • 如果存在，检查尝试次数是否已达到限制（如 3 次）。

    • 如果未达到限制，继续验证用户名和密码；如果验证失败，增加尝试次数，并重置过期时间。

    • 如果达到限制，拒绝登录并提示用户稍后再试。

代码示例

以下是使用 Redis 实现登录限制的简化代码示例：

import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;

public class LoginServiceWithRedis {

    private static final String LOGIN_ATTEMPTS_KEY_PREFIX = "login_attempts:";

    public static boolean login(String username, String password, String ip) {
        int maxAttempts = 3;
        long lockoutDurationMinutes = 10;

        Jedis jedis = new Jedis("localhost");
        try {
            String key = LOGIN_ATTEMPTS_KEY_PREFIX + ip;
            Integer attempts = (int) jedis.get(key);

            if (attempts != null && attempts >= maxAttempts) {
                long remainingTime = jedis.ttl(key);
                if (remainingTime > 0) {
                    return false; // 用户被锁定，拒绝登录
                }
            }

            if (checkPassword(username, password)) {
                jedis.del(key); // 登录成功，删除记录
                return true;
            } else {
                int newAttempts = (attempts != null) ? attempts + 1 : 1;
                jedis.setex(key, lockoutDurationMinutes * 60, newAttempts);
                return false;
            }
        } finally {
            jedis.close();
        }
    }

    private static boolean checkPassword(String username, String password) {
        // 这里应该是验证用户名和密码的逻辑
        return "password".equals(password); // 假设验证成功
    }

    public static void main(String[] args) {
        // 测试登录功能
        boolean result = login("user", "password", "192.168.1.1");
        System.out.println("Login result: " + result);
    }
}

不使用 Redis 实现登录限制

如果不使用 Redis，我们可以考虑在数据库中直接记录用户的登录尝试次数和锁定时间。

实现步骤

  1. 数据库设计：在用户表中增加两个字段，num 记录输错密码的次数，lock_time 记录禁止登录的截至时间。

  2. 检查和更新尝试次数：

    • 用户尝试登录时，检查当前时间是否在 lock_time 之后。

    • 如果在 lock_time 之后，检查 num 的值是否小于 3。

    • 如果小于 3，继续验证用户名和密码；如果验证失败，增加 num 的值。

    • 如果 num 等于 3，设置 lock_time 为当前时间加上 10 分钟，并拒绝登录。

代码示例

以下是不使用 Redis 实现登录限制的简化代码示例（假设使用 SQL 数据库）：

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL,
    password VARCHAR(50) NOT NULL,
    num INT DEFAULT 0,
    lock_time DATETIME
);


import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.Date;

public class LoginServiceWithoutRedis {

    private static final String DB_URL = "jdbc:mysql://localhost:3306/your_database";
    private static final String USER = "your_username";
    private static final String PASS = "your_password";

    public static boolean login(String username, String password, String ip) {
        int maxAttempts = 3;
        long lockoutDurationMinutes = 10;

        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;

        try {
            conn = DriverManager.getConnection(DB_URL, USER, PASS);

            String querySql = "SELECT num, lock_time FROM users WHERE username = ?";
            pstmt = conn.prepareStatement(querySql);
            pstmt.setString(1, username);
            rs = pstmt.executeQuery();

            if (rs.next()) {
                int num = rs.getInt("num");
                Timestamp lockTime = rs.getTimestamp("lock_time");

                Date now = new Date();
                if (lockTime != null && lockTime.after(now)) {
                    long remainingTime = (lockTime.getTime() - now.getTime()) / 1000 / 60;
                    System.out.println("输入密码错误次数达到 3 次，请 " + remainingTime + " 分钟后再尝试");
                    return false; // 用户被锁定，拒绝登录
                }

                if (checkPassword(username, password)) {
                    pstmt = conn.prepareStatement("UPDATE users SET num = 0, lock_time = NULL WHERE username = ?");
                    pstmt.setString(1, username);
                    pstmt.executeUpdate();
                    return true;
                } else {
                    num++;
                    if (num > maxAttempts) {
                        Date newLockTime = new Date(now.getTime() + lockoutDurationMinutes * 60 * 1000);
                        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                        String formattedDate = sdf.format(newLockTime);
                        pstmt = conn.prepareStatement("UPDATE users SET num = ?, lock_time = ? WHERE username = ?");
                        pstmt.setInt(1, num);
                        pstmt.setString(2, formattedDate);
                        pstmt.setString(3, username);
                        pstmt.executeUpdate();
                        System.out.println("输入密码错误次数达到 3 次，请 10 分钟后再尝试");
                        return false;
                    } else {
                        pstmt = conn.prepareStatement("UPDATE users SET num = ? WHERE username = ?");
                        pstmt.setInt(1, num);
                        pstmt.setString(2, username);
                        pstmt.executeUpdate();
                        System.out.println("登录失败，用户名/密码错误");
                        return false;
                    }
                }
            } else {
                System.out.println("用户不存在");
                return false;
            }
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        } finally {
            try {
                if (rs != null) rs.close();
                if (pstmt != null) pstmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    private static boolean checkPassword(String username, String password) {
        // 这里应该是验证用户名和密码的逻辑
        return "password".equals(password); // 假设验证成功
    }

    public static void main(String[] args) {
        // 测试登录功能
        boolean result = login("user", "password", "192.168.1.1");
        System.out.println("Login result: " + result);
    }
}

其他方案

除了上述两种方法，还有其他一些方案可以实现登录限制：

  1. 使用内存缓存：如果应用是单体架构，可以考虑使用内存缓存（如 Memcached）来记录登录尝试次数。

  2. 分布式锁：在分布式系统中，可以使用分布式锁（如 ZooKeeper 或 etcd）来实现跨多个节点的登录限制。

  3. 基于令牌的认证：使用基于令牌的认证机制（如 JWT），可以在令牌中包含登录尝试次数和锁定时间的信息。

结论

实现用户登录限制是保护账户安全的重要措施。通过使用 Redis、数据库或其他技术，我们可以有效地防止暴力破解等恶意攻击。在实际应用中，应根据具体需求和系统架构选择合适的方案，并考虑用户体验和系统性能的平衡。

I~Lucky
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值