SecureRandom

引用原文：https://www.cnblogs.com/deng-cc/p/8064481.html

 

我们知道，Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

 

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，生成的随机数字完全相同。

 

所以在需要频繁生成随机数，或者安全要求较高的时候，不要使用Random，因为其生成的值其实是可以预测的。

 

• SecureRandom类提供加密的强随机数生成器 (RNG)
• 当然，它的许多实现都是伪随机数生成器 (PRNG) 形式，这意味着它们将使用确定的算法根据实际的随机种子生成伪随机序列
• 也有其他实现可以生成实际的随机数
• 还有另一些实现则可能结合使用这两项技术

 

SecureRandom和Random都是，也是如果种子一样，产生的随机数也一样： 因为种子确定，随机数算法也确定，因此输出是确定的。

 

只是说，SecureRandom类收集了一些随机事件，比如鼠标点击，键盘点击等等，SecureRandom 使用这些随机事件作为种子。这意味着，种子是不可预测的，而不像Random默认使用系统当前时间的毫秒数作为种子，有规律可寻。

1. SecureRandom generater = new SecureRandom();
2. System.out.println(generater.nextInt(37));

 

1、创建SecureRandom

内置两种随机数算法，NativePRNG和SHA1PRNG，看实例化的方法了。

1.1 new

通过new来初始化，默认来说会使用NativePRNG算法生成随机数，但是也可以配置-Djava.security参数来修改调用的算法，如果是/dev/[u]random两者之一就是NativePRNG，否则就是SHA1PRNG。

 

在JVM启动参数这样加就好了，-Djava.security=file:/dev/urandom 或者 -Djava.security=file:/dev/random

1.2 getInstance

可以通过getInstance来初始化对象：

• 其中需要传参的方法，则传算法名即可，如果不存在算法会抛出异常；
• 另外需要传参，传两个参数的，第二个参数还可以指定算法程序包。

1. SecureRandom secureRandom = new SecureRandom();
2. SecureRandom secureRandom3 = SecureRandom.getInstance("SHA1PRNG");
3. SecureRandom secureRandom2 = SecureRandom.getInstance("SHA1PRNG", "SUN");

 

---

 

2、SecureRandom的使用

通常的nextInt之类的方法就不列举了，和Random的使用是类似的，这里举两个其他方法意思意思。

 

2.1 nextBytes(byte[] bytes)

Typical callers of SecureRandom invoke the following methods to retrieve random bytes: 

可以获取随机的一个byte数组，注意这里不是返回，这个方法是void返回类型，是直接随机改变了test

1. SecureRandom random = new SecureRandom();
2. byte[] test = new byte[20];
3. random.nextBytes(test);

 

2.2 generateSeed(int numBytes)

Callers may also invoke the generateSeed method to generate a given number of seed bytes (to seed other random number generators, for example): 

通常，也可以使用generateSeed方法，来获取一个随机的byte数组，这个数组中的数通常可以用来做其他随机生成器的种子

1. byte seed[] = random.generateSeed(20);

 

2.3 示例 彩票随机生成器

这是伟哥写的一个彩票生成器的代码，也是从里面我再延伸去学习的SecureRandom，如下：

1. private List<List<Integer>> generateCakes(int num, int seedLength, int rowLen) {
2. SecureRandom random = new SecureRandom();
3. // シードを生成する
4. byte[] seeds = SecureRandom.getSeed(seedLength); //获取随机的byte数组，用来后续作为种子
5. // 項目数を制御するためのカウンター
6. int counter = 0;
7. // 実際ループの回数を記録
8. int realCount = 0;
9. // 生成する組数を制御するためのカウンター
10. int tmprows = 0;
11. // 返すためのList
12. List<List<Integer>> CakesList = new ArrayList<List<Integer>>();
14. while (num > tmprows) {
15. List<Integer> list = new ArrayList<Integer>();
16. while (counter < rowLen) {
17. random.setSeed(seeds); //设置种子
18. int cake = random.nextInt(38); //随机生成0-37的数字
19. if (!list.contains(cake) && 0 != cake) {
20. list.add(cake);
21. counter++;
22. }
23. random.nextBytes(seeds); //随机获取新的byte数组用以作为下次的种子，不断循环
24. realCount++;
25. }
26. Collections.sort(list);
27. pairs++;
28. tmprows++;
29. counter = 0;
30. CakesList.add(list);
31. if (pairs % Constants.MSG_COUNT == 0) {
32. System.out.println(pairs + " cakes generated.");
33. }
34. }
36. System.out.println("乱数取得回数：" + realCount);
37. return CakesList;
38. }

 

---

 

3、其他 关于种子seed获取思路

产生高强度的随机数，有两个重要的因素：种子和算法。当然算法是可以有很多的，但是如何选择种子是非常关键的因素。

 

如Random，它的种子是System.currentTimeMillis()，所以它的随机数都是可预测的。可预测有什么危险呢，可以看两个案例：

• 《利用系统时间可预测破解java随机数》
• 《当随机不够随机：一个在线扑克游戏的教训》

 

那么如何得到一个近似随机的种子？这里有一个思路：

• 收集计算机的各种信息，如键盘输入时间，CPU时钟，内存使用状态，硬盘空闲空间，IO延时，进程数量，线程数量等信息，来得到一个近似随机的种子
• 这样的话，除了理论上有破解的可能，实际上基本没有被破解的可能。而事实上，现在的高强度的随机数生成器都是这样实现的

 

---

4、参考链接

• Java中生成随机数Random、ThreadLocalRandom、SecureRandom
• API参考 SecureRandom(示例,出错代码)
• Java中的随机数生成器：Random，ThreadLocalRandom，SecureRandom（转）
• SecureRandom的江湖偏方与真实效果
• Java 随机数 Random VS SecureRandom

 

 

Java中的随机数生成器：Random，ThreadLocalRandom，SecureRandom（转）

Random即：java.util.Random，
ThreadLocalRandom 即：java.util.concurrent.ThreadLocalRandom
SecureRandom即：java.security.SecureRandom

Q：Random是不是线程安全的？
A：Random是线程安全的，但是多线程下可能性能比较低。
参考：
http://docs.oracle.com/javase/7/docs/api/java/util/Random.html
http://stackoverflow.com/questions/5819638/is-random-class-thread-safe

Q：ThreadLocalRandom为什么这么快？
A：其实这个看下源码就知道了。。因为Random用了很多CAS的类，ThreadLocalRandom根本没有用到。

Q：为什么在高强度要求的情况下，不要用Random？

A：特别是在生成验证码的情况下，不要使用Random，因为它是线性可预测的。记得有个新闻说的是一个赌博网站，为了说明其公平，公开的它的源代码，结果因为随机数可预测漏洞被攻击了。所以在安全性要求比较高的场合，应当使用SecureRandom。

update 2014-4-22:  http://news.cnblogs.com/n/206074/

参考：http://www.inbreak.net/archives/349

Q：从理论上来说计算机产生的随机数都是伪随机数，那么如何产生高强度的随机数？
A：产生高强度的随机数，有两个重要的因素：种子和算法。当然算法是可以有很多的，但是如何选择种子是非常关键的因素。如Random，它的种子是System.currentTimeMillis()，所以它的随机数都是可预测的。那么如何得到一个近似随机的种子？这里有一个很别致的思路：收集计算机的各种信息，如键盘输入时间，CPU时钟，内存使用状态，硬盘空闲空间，IO延时，进程数量，线程数量等信息，来得到一个近似随机的种子。这样的话，除了理论上有破解的可能，实际上基本没有被破解的可能。而事实上，现在的高强度的随机数生成器都是这样实现的。
比如Windows下的随机数生成器：
http://blogs.msdn.com/b/michael_howard/archive/2005/01/14/353379.aspx
http://msdn.microsoft.com/en-us/library/aa379942%28VS.85%29.aspx
Linux下的 /dev/random：
http://zh.wikipedia.org/wiki//dev/random
据SecureRandom的Java doc，说到在类unix系统下，有可能是利用 /dev/random，来实现的。

其它的一些有意思的东东：
最快的安全性要求不高的生成UUID的方法（注意，强度不高，有可能会重复）：

new UUID(ThreadLocalRandom.current().nextLong(), ThreadLocalRandom.current().nextLong());

在一个网站上看到的，忘记出处了。

随机生成产生随机数的函数？
是否可以利用一个随机数生成器来生成一系列的随机代码，然后作为一个新的随机数生成器？貌似强度是传递的，似乎没意义。

http://blog.csdn.net/hengyunabc/article/details/9913143

 

2. JDK7的SecureRandom

2.1 generateSeed()与next*()

generateSeed()可以为其他安全算法生成种子，随机度需求更高些。
nextInt(), nextLong()则是我们更关心的生成随机数，最后都是调用nextBytes()。

2.2 seedSource

seedSource由两者决定，首先看 -Djava.security.egd ,
没设置则看jre/lib/security/java.security，JDK7中securerandom.source=file:/dev/urandom

 

2.3 SHA1PRNG 与 NativePRNG

从名字就知道，两者都是伪随机算法。另外，两种算法都会有synchronized关键字，都会有阻塞，只有时间长短的不同。

2.3.1 SHA1PRNG

generateSeed()的实现：只要配置的seedSource是/dev/random 或 /dev/urandom，就会使用NativeSeedGenerator，而此君在JDK7里有bug，只从/dev/random 取值，有可能被阻塞。

nextBytes()的实现： 纯Java实现，通过不断的对当前Hash值进行再一次SHA1哈希而成。

那Hash的初始值怎么来？如果没有被外部显式设置，则用下面比较复杂的算法生成(可跳过不看)。

• 先有个SecureRandom seeder，并且用java从系统收集到一些噪音作为这个SR的初始seed。
• 调用generateSeed() ， 获得一个seed，可能被阻塞（见上）。
• 调用seeder.setSeed(seed) ，合并1和2的seed。
• 最后调用seeder.nextBytes()，生成最后的seed。

2.3.2 NativePRNG

generateSeed()的实现：从/dev/random中取值，可能阻塞。

nextBytes()的实现：从/dev/urandom 中取值，再异或 SHA1PRNG生成的随机值而成。

可见NativePRGN的性能一定会比单纯SHA1PRNG差，synchronized的代码也多一倍。

那为什么要异或 SHA1PRNG呢？为了支持setSeed()，/dev/[u]random都是不可写的，只好再引入一个可设置seed的SHA1PRNG。

/dev/[u]random不需要Java应用来給种子，而SHA1PRNG则从/dev/urandom中获得种子并显式设置，也就不需要2.3.1中所述的种子四步曲，所以不会阻塞。

 

2.3.3 算法的选择

如果用getInstance()获取，则返回的是特定算法的实现。

如果用new SecureRandom()， 则看seedSource的设置，如果是/dev/[u]random 之一则是NativePRNG，否则是SHA1PRNG，比如-Djava.security=file:/dev/./urandom，多了个./在中间, 就成了SHA1PRNG了。

 

3. 江湖偏方的诞生

在JDK7，默认算法是NativePRNG，里面/dev/urandom本身不用seed，而用到的SHA1PRNG的初始seed也从/dev/urandom 读取，不存在启动慢的问题。就是消耗和延时比纯SHA1PRNG大。

然后Tomcat 生成sessionId时显式使用了SHA1PRNG，因为NativeSeedGenerator的bug，此时初始seed要从/dev/random读取，就存在启动慢的可能（见2.3.1）。所以要设置seedSoure而且要加个./在中间，绕过NativeSeedGenerator改为用URLSeedGenderator。

如果一个不明真相的群众，也跟着设置-Djava.security=file:/dev/./urandom, 一个意外的效果就是，默认的算法也变成SHA1PRNG了。

 

4. JDK8的SecureRandom

首先，Native算法多了两种子类型。NativeBlocking的generateSeed与nextBytes都从/dev/random中读，NativeNonBlocking则两者都从/dev/urandom中读。

不过Native里nextBytes并不需要调用generateSeed，所以对于主要用SecureRandom来生成随机数的应用来说，这个区别不大。

其次，SHA1PRNG用到的SeedGenerator，终于改好了，原来NativeSeedGenerator无论设什么都是读/dev/random，现在改为设什么就读什么，所以jre/lib/security/java.security 里也改了 securerandom.source=file:/dev/random

所以，JDK8里，如果你显式获得的SHA1PRNG以后启动不想有阻塞的可能性，还是要设成-Djava.security=file:/dev/urandom，只是不用猥琐的加个. 在中间了。不过依然加上也无不可。

如果你想把默认算法搞成SHA1PRNG，那还是要继续江湖偏方。

 

5. 结论

• SHA1PRNG 比 NativePRNG消耗小一半，synchronized的代码少一半，不与系统/dev/urandom交互所以偶发高延时也更少一些，所以没特殊安全要求的话建议用SHA1，比如生成sessionId，traceId的场景
• 如果想用SHA1， 设成-Djava.security=file:/dev/./urandom总是对的
• 如果想用Native，什么都不设置就好了。
• 如果自己能控制，在应用或框架启动时，先调用一下相应SecureRandom算法实例的nextInt()函数，总能减少一点首次服务调用所花的时间。

Java 随机数 Random VS SecureRandom

 

专职跑龙套 关注

2016.11.10 12:10* 字数 1344 阅读 3076评论 0喜欢 3

1. Math.random() 静态方法

产生的随机数是0 - 1之间的一个double，即 0 <= random <= 1。
使用：

for (int i = 0; i < 10; i++) {
  System.out.println(Math.random());
}

结果：

0.3598613895606426
0.2666778145365811
0.25090731064243355
0.011064998061666276
0.600686228175639
0.9084006027629496
0.12700524654847833
0.6084605849069343
0.7290804782514261
0.9923831908303121

实现原理：

When this method is first called, it creates a single new pseudorandom-number generator, exactly as if by the expression
new java.util.Random()
This new pseudorandom-number generator is used thereafter for all calls to this method and is used nowhere else.
当第一次调用Math.random()方法时，自动创建了一个伪随机数生成器，实际上用的是new java.util.Random()。
当接下来继续调用Math.random()方法时，就会使用这个新的伪随机数生成器。

源码如下：

public static double random() {
    Random rnd = randomNumberGenerator;
    if (rnd == null) rnd = initRNG(); // 第一次调用，创建一个伪随机数生成器
    return rnd.nextDouble();
}

private static synchronized Random initRNG() {
    Random rnd = randomNumberGenerator;
    return (rnd == null) ? (randomNumberGenerator = new Random()) : rnd; // 实际上用的是new java.util.Random()
}

This method is properly synchronized to allow correct use by more than one thread. However, if many threads need to generate pseudorandom numbers at a great rate, it may reduce contention for each thread to have its own pseudorandom-number generator.
initRNG()方法是synchronized的，因此在多线程情况下，只有一个线程会负责创建伪随机数生成器（使用当前时间作为种子），其他线程则利用该伪随机数生成器产生随机数。
因此Math.random()方法是线程安全的。

什么情况下随机数的生成线程不安全：

• 线程1在第一次调用 random 时产生一个生成器 generator1，使用当前时间作为种子。
• 线程2在第一次调用 random 时产生一个生成器 generator2，使用当前时间作为种子。
• 碰巧 generator1 和 generator2 使用相同的种子，导致 generator1 以后产生的随机数每次都和 generator2 以后产生的随机数相同。

什么情况下随机数的生成线程安全： Math.random() 静态方法使用

• 线程1在第一次调用 random 时产生一个生成器 generator1，使用当前时间作为种子。
• 线程2在第一次调用 random时发现已经有一个生成器 generator1，则直接使用生成器 generator1。

public class JavaRandom {
    public static void main(String args[]) {
        new MyThread().start();
        new MyThread().start();
    }
}
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + Math.random());
        }
    }
}

结果：

Thread-1: 0.8043581595645333
Thread-0: 0.9338269554390357
Thread-1: 0.5571569413128877
Thread-0: 0.37484586843392464

2. java.util.Random 工具类

基本算法：linear congruential pseudorandom number generator (LGC) 线性同余法伪随机数生成器
缺点：可预测

An attacker will simply compute the seed from the output values observed. This takes significantly less time than 2^48 in the case of java.util.Random.
从输出中可以很容易计算出种子值。
It is shown that you can predict future Random outputs observing only two(!) output values in time roughly 2^16.
因此可以预测出下一个输出的随机数。
You should never use an LCG for security-critical purposes.
在注重信息安全的应用中，不要使用 LCG 算法生成随机数，请使用 SecureRandom。

使用：

Random random = new Random();

for (int i = 0; i < 5; i++) {
    System.out.println(random.nextInt());
}

结果：

-24520987
-96094681
-952622427
300260419
1489256498

Random类默认使用当前系统时钟作为种子:

public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}

public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // subclass might have overriden setSeed
        this.seed = new AtomicLong();
        setSeed(seed);
    }
}

Random类提供的方法：API

• nextBoolean() - 返回均匀分布的 true 或者 false
• nextBytes(byte[] bytes)
• nextDouble() - 返回 0.0 到 1.0 之间的均匀分布的 double
• nextFloat() - 返回 0.0 到 1.0 之间的均匀分布的 float
• nextGaussian() - 返回 0.0 到 1.0 之间的高斯分布（即正态分布）的 double
• nextInt() - 返回均匀分布的 int
• nextInt(int n) - 返回 0 到 n 之间的均匀分布的 int （包括 0，不包括 n）
• nextLong() - 返回均匀分布的 long
• setSeed(long seed) - 设置种子

只要种子一样，产生的随机数也一样： 因为种子确定，随机数算法也确定，因此输出是确定的！

Random random1 = new Random(10000);
Random random2 = new Random(10000);

for (int i = 0; i < 5; i++) {
    System.out.println(random1.nextInt() + " = " + random2.nextInt());
}

结果：

-498702880 = -498702880
-858606152 = -858606152
1942818232 = 1942818232
-1044940345 = -1044940345
1588429001 = 1588429001

3. java.util.concurrent.ThreadLocalRandom 工具类

ThreadLocalRandom 是 JDK 7 之后提供，也是继承至 java.util.Random。

private static final ThreadLocal<ThreadLocalRandom> localRandom =
    new ThreadLocal<ThreadLocalRandom>() {
        protected ThreadLocalRandom initialValue() {
            return new ThreadLocalRandom();
        }
};

每一个线程有一个独立的随机数生成器，用于并发产生随机数，能够解决多个线程发生的竞争争夺。效率更高！
ThreadLocalRandom 不是直接用 new 实例化，而是第一次使用其静态方法 current() 得到 ThreadLocal<ThreadLocalRandom> 实例，然后调用 java.util.Random 类提供的方法获得各种随机数。
使用：

public class JavaRandom {
    public static void main(String args[]) {
        new MyThread().start();
        new MyThread().start();
    }
}
class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 2; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + ThreadLocalRandom.current().nextDouble());
        }
    }
}

结果：

Thread-0: 0.13267085355389086
Thread-1: 0.1138484950410098
Thread-0: 0.17187774671469858
Thread-1: 0.9305225910262372

4. java.Security.SecureRandom

也是继承至 java.util.Random。

Instances of java.util.Random are not cryptographically secure. Consider instead using SecureRandom to get a cryptographically secure pseudo-random number generator for use by security-sensitive applications.
SecureRandom takes Random Data from your os (they can be interval between keystrokes etc - most os collect these data store them in files - /dev/random and /dev/urandom in case of linux/solaris) and uses that as the seed.
操作系统收集了一些随机事件，比如鼠标点击，键盘点击等等，SecureRandom 使用这些随机事件作为种子。

This class provides a cryptographically strong random number generator (RNG).
SecureRandom 提供加密的强随机数生成器 (RNG)，要求种子必须是不可预知的，产生非确定性输出。
SecureRandom 也提供了与实现无关的算法，因此，调用方（应用程序代码）会请求特定的 RNG 算法并将它传回到该算法的 SecureRandom 对象中。

• 如果仅指定算法名称，如下所示：
  SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

• 如果既指定了算法名称又指定了包提供程序，如下所示：
  SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");

使用：

SecureRandom random1 = SecureRandom.getInstance("SHA1PRNG");
SecureRandom random2 = SecureRandom.getInstance("SHA1PRNG");

for (int i = 0; i < 5; i++) {
    System.out.println(random1.nextInt() + " != " + random2.nextInt());
}

结果：

704046703 != 2117229935
60819811 != 107252259
425075610 != -295395347
682299589 != -1637998900
-1147654329 != 1418666937

---

 

 

 

 

 

demo范例：


public static void main(String[] args) {
new SHA1PRNG().print();
/**
* 随机数：
* 1.Random
* 2.ThreadLocalRandom：ThreadLocalRandom执行效率Random快，Random在生成随机数的时候使用了CAS,但是ThreadLocalRandom却没有使用
* 3.SecureRandom:在需要频繁生成随机数，或者安全要求较高的时候，不要使用Random，Random生成的值其实是可以预测的
* 内置算法：内置两种随机数算法，NativePRNG和SHA1PRNG
* 特别是在生成验证码的情况下，不要使用Random，因为它是线性可预测的。所以在安全性要求比较高的场合，应当使用SecureRandom
* 产生高强度的随机数，有两个重要的因素：种子和算法
* 当然算法是可以有很多的，但是如何选择种子是非常关键的因素。如Random，它的种子是System.currentTimeMillis()，
* 所以它的随机数都是可预测的。那么如何得到一个近似随机的种子？
* 这里有一个很别致的思路：收集计算机的各种信息，如键盘输入时间，CPU时钟，内存使用状态，硬盘空闲空间，IO延时，进程数量，线程数量等信息，来得到一个近似随机的种子。
* 这样的话，除了理论上有破解的可能，实际上基本没有被破解的可能。而事实上，现在的高强度的随机数生成器都是这样实现的。
* setSeed(long seed) - 设置种子 只要种子一样，产生的随机数也一样
*/
ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
int a =threadLocalRandom.nextInt(5);
System.out.println(a);

SecureRandom secureRandom3;
try {
secureRandom3 = SecureRandom.getInstance("SHA1PRNG");
a=secureRandom3.nextInt();
System.out.println(a);
} catch (NoSuchAlgorithmException e) {
}

}

/**
* 知识扩展:随机数算法
*/
static class SHA1PRNG {
public void print(){
try{
// Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
SecureRandom rng = SecureRandom.getInstance("SHA1PRNG");
// rng.setSeed(21); //设置种子 种子相同随机数想
// 生成随机数
int numberToGenerate = 10;
byte randNumbers[] = new byte[numberToGenerate];
rng.nextBytes(randNumbers);
// 打印随机数
for (int j = 0; j < numberToGenerate; j++) {
System.out.print(randNumbers[j] + " ");
}
}catch(Exception e){

}
}
}