首先得说，你当前用java.util.Random生成OTP的方式存在安全性隐患——它是伪随机数生成器，基于线性同余算法，生成的序列可以通过部分输出被预测，完全不符合OTP需要的“不可预测性”要求，一旦被攻击者盯上，很容易被破解。

下面给你几个更优质、更安全的替代方案：

一、使用JDK自带的SecureRandom（推荐） #

java.security.SecureRandom是专门为密码学场景设计的随机数生成器，它会从系统的安全随机源（比如操作系统的熵池）获取种子，生成的随机数无法被预测，完全满足OTP的安全需求。

示例代码： #

import java.security.SecureRandom;

public class SecureOTPGenerator {
    static char[] generateOTP(int len) {
        System.out.println("Generating secure OTP using SecureRandom:");
        System.out.print("Your OTP is: ");
        
        // 仅使用数字作为OTP字符集
        String numbers = "0123456789";
        char[] otp = new char[len];
        SecureRandom secureRandom = new SecureRandom();
        
        for (int i = 0; i < len; i++) {
            // 生成0到numbers长度-1之间的安全随机索引
            int index = secureRandom.nextInt(numbers.length());
            otp[i] = numbers.charAt(index);
        }
        return otp;
    }

    public static void main(String[] args) {
        System.out.println(generateOTP(6));
    }
}

二、实现符合RFC标准的TOTP（基于时间的一次性密码） #

如果你的OTP是用于身份验证（比如类似Google Authenticator的动态验证码），推荐实现TOTP（Time-Based One-Time Password），它基于HMAC-SHA算法和当前时间戳生成OTP，完全符合RFC 6238标准，安全性极高，且是行业通用方案。

核心实现思路： #

1. 服务器和客户端共享一个密钥（Secret Key）
2. 以固定时间窗口（比如30秒）为单位，计算当前时间窗口的哈希值
3. 从哈希值中提取固定长度的数字作为OTP

简化示例代码： #

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;

public class TOTPGenerator {
    private static final String HMAC_ALGORITHM = "HmacSHA1";
    private static final int TIME_STEP = 30; // 时间窗口，单位秒
    private static final int OTP_LENGTH = 6;

    public static String generateTOTP(String secretKey) throws NoSuchAlgorithmException, InvalidKeyException {
        // 获取当前时间窗口的起始时间戳
        long timestamp = Instant.now().getEpochSecond() / TIME_STEP;
        byte[] timestampBytes = ByteBuffer.allocate(8).putLong(timestamp).array();

        // 初始化HMAC算法
        SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), HMAC_ALGORITHM);
        Mac mac = Mac.getInstance(HMAC_ALGORITHM);
        mac.init(keySpec);

        // 计算HMAC哈希值
        byte[] hmacBytes = mac.doFinal(timestampBytes);

        // 动态截断哈希值，提取OTP
        int offset = hmacBytes[hmacBytes.length - 1] & 0x0F;
        int binary = ((hmacBytes[offset] & 0x7F) << 24) |
                     ((hmacBytes[offset + 1] & 0xFF) << 16) |
                     ((hmacBytes[offset + 2] & 0xFF) << 8) |
                     (hmacBytes[offset + 3] & 0xFF);

        // 生成固定长度的OTP，不足补0
        String otp = Integer.toString(binary % (int) Math.pow(10, OTP_LENGTH));
        return String.format("%0" + OTP_LENGTH + "d", Integer.parseInt(otp));
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {
        // 注意：实际场景中密钥应安全存储，且客户端和服务器保持一致
        String sharedSecret = "YOUR_SHARED_SECRET_KEY";
        System.out.println("TOTP: " + generateTOTP(sharedSecret));
    }
}

三、可选：使用第三方工具库 #

如果不想自己实现，也可以用成熟的第三方库简化开发，比如：

• Apache Commons Codec：用RandomStringUtils.random(len, false, true)生成数字OTP（底层也是基于SecureRandom）
• Google Guava：用Randoms.secureRandom()结合字符集生成OTP

不过如果项目对依赖包大小有要求，优先用JDK自带的SecureRandom即可。

内容的提问来源于stack exchange，提问作者user1529641