Insecure Randomness: Hardcoded Seed

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como a classe CL_ABAP_RANDOM ou suas variantes) for propagado com um valor constante específico, os valores retornados por GET_NEXT, INT e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas PRNG.

Exemplo 1: No trecho a seguir, os valores produzidos pelo objeto random_gen2 são previsíveis por meio do objeto random_gen1.

		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.

Neste exemplo, os geradores de números pseudoaleatórios: random_gen1 e random_gen2 foram semeados de forma idêntica, então var1 = var2

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como rand()) for propagado com um valor específico (usando uma função como srand(unsigned int)), os valores retornados por rand() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas de PRNG.

Exemplo 1: Os valores produzidos pelo gerador de números pseudoaleatórios são previsíveis nos dois primeiros blocos, pois ambos começam com o mesmo propagador.

        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);

Nesse exemplo, os resultados para randomNum1 e randomNum2 foram identicamente propagados e, portanto, cada chamada para rand() após a chamada que propaga o gerador de números pseudoaleatórios srand(2223333) resultará nas mesmas saídas, na mesma ordem de chamada. Por exemplo, a saída pode ser semelhante à seguinte:

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

Esses resultados estão longe de serem aleatórios.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (PRNG) for propagado com um valor específico (usando uma função como math.Rand.New(Source)), os valores retornados por math.Rand.Int() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas do PRNG.

Exemplo 1: Os valores produzidos pelo gerador de números pseudoaleatórios são previsíveis nos dois primeiros blocos, pois ambos começam com o mesmo propagador.

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

Neste exemplo, os PRNGs foram propagados com o mesmo valor. Assim, cada chamada denextInt() após a chamada que iniciou a propagação do gerador de números pseudoaleatórios (randomGen.Seed(12345)) resultará nas mesmas saídas, na mesma ordem.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como Random) for propagado com um valor específico (usando uma função como Random(Int)), os valores retornados por Random.nextInt() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas de PRNG.

Exemplo 1: Os valores produzidos pelo objeto RandomrandomGen2 são previsíveis com base no objeto RandomrandomGen1.

        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)

Neste exemplo, os geradores de números pseudoaleatórios: randomGen1 e randomGen2 foram propagados de forma idêntica e, portanto, randomInt1 == randomInt2 e os valores correspondentes dos arrays byteArray1 e byteArray2 são iguais.

As funções que geram valores aleatórios ou pseudoaleatórios, que são passados a uma semente, não devem ser chamadas com um argumento inteiro constante.

As funções que geram valores pseudoaleatórios, que são passados a uma semente, não devem ser chamadas com um argumento inteiro constante. Se um gerador de números pseudoaleatórios for semeado com um valor específico, os valores devolvidos serão previsíveis.

Exemplo 1: Os valores produzidos pelo gerador de números pseudoaleatórios são previsíveis nos dois primeiros blocos, pois ambos começam com o mesmo propagador.

...
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)
...

Nesse exemplo, os PRNGs foram semeados de maneira idêntica, para que cada chamada de randint() feita depois da chamada que semeou o gerador de números pseudoaleatórios (random.seed(123456)), resulte nas mesmas saídas na mesma ordem. Por exemplo, a saída pode ser semelhante à seguinte:

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

Esses resultados estão longe de serem aleatórios.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante.

Funções que geram valores aleatórios ou pseudoaleatórios, que são transmitidos para um propagador, não devem ser chamadas com um argumento constante. Se um gerador de números pseudoaleatórios (como Random) for propagado com um valor específico (usando uma função como Random.setSeed()), os valores retornados por Random.nextInt() e métodos semelhantes que retornam ou atribuem valores serão previsíveis para um invasor, que poderá coletar várias saídas de PRNG.

Exemplo 1: Os valores produzidos pelo objeto RandomrandomGen2 são previsíveis com base no objeto RandomrandomGen1.

        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)

Neste exemplo, os geradores de números pseudoaleatórios: randomGen1 e randomGen2 foram propagados de forma idêntica e, portanto, randomInt1 == randomInt2 e os valores correspondentes dos arrays bytes1[] e bytes2[] são iguais.