Insecure Randomness: Hardcoded Seed

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 CL_ABAP_RANDOM 类或其变体）使用特定常数值作为种子，则通过 GET_NEXT、INT 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：在以下摘录的代码中，可以通过对象 random_gen1 来预测对象 random_gen2 生成的值。

		DATA: random_gen1 TYPE REF TO cl_abap_random,
			  random_gen2 TYPE REF TO cl_abap_random,
			  var1 TYPE i,
			  var2 TYPE i.

		random_gen1 = cl_abap_random=>create( seed = '1234' ).

		DO 10 TIMES.
			CALL METHOD random_gen1->int
				RECEIVING
			value  = var1.

			WRITE:/ var1.
		ENDDO.

		random_gen2 = cl_abap_random=>create( seed = '1234' ).

		DO 10 TIMES.
			CALL METHOD random_gen2->int
				RECEIVING
			value  = var2.

			WRITE:/ var2.
		ENDDO.

在此示例中，伪随机数值生成器：random_gen1 和 random_gen2 设置了相同的种子，因此 var1 = var2

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 rand()）使用特定值作为种子（使用类似 srand(unsigned int) 的函数），则通过 rand() 和通过可返回或分配值的类似方法返回的值对可以收集一定数量 PRNG 输出的攻击者来说是可预测的。

示例 1：伪随机数生成器生成的值在前两个块中是可预测的，因为这两个块以同一种子开始。

        srand(2223333);
        float randomNum = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum);
        randomNum = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum);

        srand(2223333);
        float randomNum2 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum2);
        randomNum2 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum2);

        srand(1231234);
        float randomNum3 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum3);
        randomNum3 = (rand() % 100);
        syslog(LOG_INFO, "Random: %1.2f", randomNum3);

在此例子中，randomNum1 和 randomNum2 的结果设置相同的种子，因此在为伪随机数值生成器 srand(2223333) 设置种子的调用后，对 rand() 的每次调用都将会以相同的调用顺序产生相同的输出。例如，输出可能与以下内容相似：

Random: 32.00
Random: 73.00
Random: 32.00
Random: 73.00
Random: 15.00
Random: 75.00

这些结果并不是随机的。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器 (PRNG) 使用特定值作为种子（使用诸如 math.Rand.New(Source) 的函数），则通过 math.Rand.Int() 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：伪随机数生成器生成的值在前两个块中是可预测的，因为这两个块以同一种子开始。

  randomGen := rand.New(rand.NewSource(12345))
  randomInt1 := randomGen.nextInt()
  
  randomGen.Seed(12345)
  randomInt2 := randomGen.nextInt()

在此示例中，PRNG 设置了相同的种子，因此在为伪随机数值生成器 (randomGen.Seed(12345)) 设置种子的调用之后，每次调用 nextInt() 都会产生相同的输出和顺序。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 Random）使用特定值作为种子（使用诸如 Random(Int) 的函数），则通过 Random.nextInt() 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：可以通过 Random 对象 randomGen1 来预测 Random 对象 randomGen2 生成的值。

        val randomGen1 = Random(12345)
        val randomInt1 = randomGen1.nextInt()
        val byteArray1 = ByteArray(4)
        randomGen1.nextBytes(byteArray1)

        val randomGen2 = Random(12345)
        val randomInt2 = randomGen2.nextInt()
        val byteArray2 = ByteArray(4)
        randomGen2.nextBytes(byteArray2)

在此示例中，伪随机数值生成器：randomGen1 和 randomGen2 设置了相同的种子，因此 randomInt1 == randomInt2，且数组 byteArray1 和 byteArray2 的相应值是相等的。

可生成随机或伪随机值的传递种子的函数不应使用常量整数参数进行调用。

可生成伪随机值的传递种子的函数不应使用常量整数参数进行调用。如果伪随机数生成器使用特定值作为种子，则返回的值可预测。

示例 1：伪随机数生成器生成的值在前两个块中是可预测的，因为这两个块以同一种子开始。

...
import random
random.seed(123456)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)

random.seed(123456)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)
print "Random: %d" % random.randint(1,100)
...

在此示例中，PRNG 设置了相同的种子，因此，在为伪随机数生成器 (random.seed(123456)) 设置种子的调用后，对 randint() 的每次调用都将会导致按相同的顺序显示相同的输出。例如，输出可能与以下内容相似：

Random: 81
Random: 80
Random: 3
Random: 81
Random: 80
Random: 3

这些结果并不是随机的。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。

可生成随机或伪随机值的传递了种子的函数不应使用常量参数进行调用。如果伪随机数值生成器（如 Random）使用特定值作为种子（使用诸如 Random.setSeed() 的函数），则通过 Random.nextInt() 和通过可返回或分配值的类似方法返回的值对可以收集大量 PRNG 输出的攻击者来说是可预测的。

示例 1：可以通过 Random 对象 randomGen1 来预测 Random 对象 randomGen2 生成的值。

        val randomGen1 = new Random()
        randomGen1.setSeed(12345)
        val randomInt1 = randomGen1.nextInt()
        val bytes1 = new byte[4]
        randomGen1.nextBytes(bytes1)

        val randomGen2 = new Random()
        randomGen2.setSeed(12345)
        val randomInt2 = randomGen2.nextInt()
        val bytes2 = new byte[4]
        randomGen2.nextBytes(bytes2)

在此示例中，伪随机数值生成器：randomGen1 和 randomGen2 设置了相同的种子，因此 randomInt1 == randomInt2，且数组 bytes1[] 和 bytes2[] 的相应值是相等的。