CSPRNG: algoritmos aleatórios também precisam de segurança!

Se eu jogar uma moeda para o alto, sei qual será o resultado: cara ou coroa. No entanto, não consigo prever qual dos dois será. Posso certamente tentar adivinhar, com 50% de chance de acertar, mas não tenho como ter 100% de certeza. Se eu jogar um dado, minha chance de acertar diminui (1 em 6). Ainda assim, sei quais resultados são possíveis.

Computadores são ótimos em muitas coisas, especialmente em previsibilidade. Eles são determinísticos, então é impossível gerar um número verdadeiramente aleatório. No entanto, podemos usar funções para gerar uma aleatoriedade aproximada. Essas funções são chamadas de geradores de números pseudoaleatórios. 

Vamos dar uma olhada em um pouco de código:

1import random
2
3# Generate a random integer between 0 and 10
4random_number = random.randint(0, 10)
5
6print(random_number)

Este código gera um número aleatório de 0 a 10 (incluindo 0 e 10 entre os resultados possíveis). É parecido com o lançamento da moeda e do dado que vimos antes. Sabemos quais resultados podem ocorrer, só não conseguimos prever com precisão qual será.

Quando lidamos com criptografia, queremos que a previsibilidade seja zero. Ou seja, não queremos conseguir prever o resultado em hipótese alguma. Por exemplo, digamos que vamos gerar um token “aleatório” para redefinir uma senha. Podemos usar o horário atual para gerar um valor de hash. Quando ele aparecer na URL de redefinição de senha, parecerá aleatório. Mas, na verdade, é previsível. E um hacker pode tirar proveito disso, principalmente se o código for aberto e estiver disponível para consulta.

1import hashlib
2import time
3
4t = time.localtime()
5current_time = time.strftime("%H:%M:%S", t)
6
7MD5_hash = hashlib.md5(current_time.encode())
8
9print(MD5_hash.hexdigest())

A aleatoriedade é um conceito que varia de uma área para outra. Em alguns casos, como em um cassino, girar a roleta é algo aleatório, embora, estatisticamente, haja 2,6% de chance de o resultado poder ser “previsto”. Em criptografia, isso não é suficiente!

Pseudoaleatório não é seguro

Vimos acima os geradores de números pseudoaleatórios (PRNG), mas precisamos de algo melhor. Para que um número aleatório seja seguro para fins criptográficos, ele precisa ser imprevisível, não se repetir e não apresentar padrões. Queremos usar geradores de números pseudoaleatórios criptograficamente seguros (CSPRNG).

Um CSPRNG é um tipo de gerador de números aleatórios projetado especificamente para ser seguro em aplicações criptográficas. Esses geradores produzem uma sequência de números aleatórios difícil de prever ou reproduzir, mesmo quando se conhece o algoritmo e o valor da semente usado para inicializar o gerador. Em outras palavras, ela precisa ser imprevisível. Além disso, um CSPRNG deve conseguir gerar uma grande quantidade de números aleatórios sem repetições ou padrões identificáveis na sequência.

CSPRNGs são usados em diversas aplicações criptográficas, como geração de chaves, hash de senhas e criptografia. Também são usados em aplicações não criptográficas, como na geração de IDs exclusivos, tokens e chaves de sessão.

CSPRNG e entropia

De onde vem o “CS” em CSPRNG? A resposta está na entropia.

Entropia é uma medida da aleatoriedade ou incerteza em uma fonte de dados. Ela é uma parte essencial de um CSPRNG. Pools de entropia são fontes de dados aleatórios usadas para inicializar CSPRNGs e reabastecê-los periodicamente, garantindo que os números gerados continuem imprevisíveis.

Os CSPRNGs podem obter dados de diferentes tipos de pools de entropia, e a implementação específica de um CSPRNG determina quais pools ele usa. Há geradores de números aleatórios de hardware (HRNGs), dispositivos físicos que usam várias fontes de aleatoriedade, como ruído eletrônico, decaimento radioativo ou ruído atmosférico, para gerar números aleatórios. Eles são considerados boas fontes de entropia porque é difícil prever ou reproduzir os processos físicos usados para gerar os números.

Alguns sistemas operacionais oferecem uma fonte de entropia que pode ser usada para inicializar CSPRNGs. Por exemplo, os arquivos /dev/random ou /dev/urandom em sistemas Linux e semelhantes ao UNIX, e BCryptGenRandom() no Windows. Se você usa Python, pode usar os.urandom() para retornar bytes aleatórios usando a fonte de aleatoriedade específica do seu sistema operacional.

Os CSPRNGs também podem coletar entropia de várias fontes ambientais, como tráfego de rede, movimentos do mouse ou entradas do teclado. Essas fontes podem ser imprevisíveis e fornecer uma boa quantidade de entropia. Você pode ir ainda mais longe, como a CloudFlare, e usar lâmpadas de lava!

Exemplo de CSPRNG

Continuando com Python, veja um exemplo de geração de um token seguro para uso em URLs:

1import secrets
2
3print (secrets.token_urlsafe(16))

Isso vai gerar um número pseudoaleatório criptograficamente seguro. Podemos usá-lo para diversas finalidades, como gerar um token de redefinição de senha. Esse token é inserido na URL e pode ter uma aparência parecida com esta: https://supersecurereset.io/forgot-password?token=3PDhWtzkTo9QGAq6mvLxYA

Saiba mais sobre aleatoriedade e segurança

Aleatoriedade insegura e recuperação de senhas são apenas uma pequena parte da segurança de computadores. É preciso muita coisa para criar um ambiente e uma aplicação seguros. Não esperamos que ninguém saiba tudo, e é por isso que existe o Snyk Learn.

Snyk Learn é uma ótima ferramenta de aprendizado, com conteúdo criado por especialistas em segurança. E o melhor: é grátis. Grátis mesmo. Não é uma demonstração — e você pode fazer quantas aulas quiser, sem limites. 

Para saber mais sobre aleatoriedade e métodos de recuperação de senhas, confira estas duas aulas:

• Aleatoriedade insegura: JavaScript

• Recuperação de senha fraca: JavaScript