Générateurs de nombres aléatoires expliqués : PRNG vs TRNG et comment ils fonctionnent

Introduction

Les nombres aléatoires sont partout dans la vie moderne, même si on n’y pense jamais. Chaque fois que vous mélangez une liste de lecture, tirez des numéros de loterie, chiffrez un message, exécutez une simulation scientifique ou voyez un CAPTCHA, des générateurs de nombres aléatoires travaillent en coulisses. L’industrie mondiale de la cybersécurité dépend du caractère aléatoire des clés de chiffrement qui protègent chaque jour des milliers de milliards de dollars de transactions.

Mais voici le paradoxe : les ordinateurs sont des machines déterministes. Ils exécutent les instructions dans une séquence précise et reproductible. Alors, comment une machine déterministe peut-elle produire quelque chose d’imprévisible ?

La réponse implique un mélange fascinant de mathématiques, de physique et d’ingénierie. Il existe des générateurs qui récoltent le caractère aléatoire du monde physique, des générateurs qui utilisent des algorithmes intelligents pour produire des séquences qui semblent aléatoires et des générateurs hybrides qui combinent les deux approches pour la sécurité cryptographique.

Ce guide explique le fonctionnement des générateurs de nombres aléatoires, les différences critiques entre la génération véritablement aléatoire et pseudo-aléatoire, l'origine de l'entropie à l'origine du caractère aléatoire, les applications du monde réel, les échecs notables qui ont révélé les faiblesses des systèmes de nombres aléatoires et des exemples de programmation pratiques.

Essayez notre générateur de nombres aléatoires gratuit pour générer instantanément des nombres aléatoires avec des plages, des quantités et des options de non-répétition personnalisées.

---

Qu'est-ce qu'un générateur de nombres aléatoires ?

Un générateur de nombres aléatoires (RNG) est tout processus ou dispositif qui produit une séquence de nombres sans motif perceptible. Dans un RNG idéal, chaque nombre de la sortie est statistiquement indépendant de tous les autres, et chaque valeur possible dans la plage a une probabilité égale d'être sélectionnée.

En pratique, il existe un spectre de « qualité aléatoire » selon la méthode utilisée :

• Les véritables générateurs de nombres aléatoires (TRNG) produisent des nombres véritablement imprévisibles dérivés de phénomènes physiques
• Les générateurs de nombres pseudo-aléatoires (PRNG) produisent des séquences déterministes qui semblent aléatoires mais sont entièrement reproductibles dans les mêmes conditions de départ.
• Les PRNG cryptographiquement sécurisés (CSPRNG) sont un sous-ensemble de PRNG conçus pour être impossibles à prédire par ordinateur, même si un attaquant connaît l'algorithme.

Comprendre quel type utiliser dépend entièrement de l’application. Un jeu vidéo a besoin d’un caractère aléatoire rapide et suffisamment bon. Un système de cryptage nécessite un caractère aléatoire imprévisible sur le plan informatique. Une simulation physique peut nécessiter un caractère aléatoire reproductible pour la vérification.

---

Générateurs de vrais nombres aléatoires (TRNG)

Les véritables générateurs de nombres aléatoires tirent leurs résultats de phénomènes physiques fondamentalement imprévisibles. Ceux-ci sont également appelés générateurs matériels de nombres aléatoires.

Sources d'entropie courantes

Bruit thermique : Les composants électroniques génèrent de minuscules fluctuations de tension en raison du mouvement aléatoire des électrons à toute température supérieure au zéro absolu. Ces fluctuations sont véritablement aléatoires au niveau quantique et peuvent être amplifiées et numérisées.

Bruit atmosphérique : Les récepteurs radio réglés entre les stations captent le bruit électromagnétique atmosphérique provenant des éclairs et d'autres phénomènes naturels. Le service random.org utilise le bruit atmosphérique pour générer des nombres aléatoires.

Désintégration radioactive : Le moment des événements de désintégration radioactive est régi par la mécanique quantique et est fondamentalement imprévisible. Les clics du compteur Geiger peuvent être convertis en bits aléatoires.

Comportement des photons : Lorsqu'un seul photon frappe un séparateur de faisceau, la mécanique quantique indique qu'il a 50/50 de chances d'être transmis ou réfléchi. Cela produit des bits véritablement aléatoires à grande vitesse.

Gigue d'horloge : Les légères variations de synchronisation de l'horloge du processeur, causées par les effets thermiques et le bruit électrique, constituent une source d'entropie disponible dans n'importe quel ordinateur.

Avantages et limites

Avantages :

• Produit une sortie véritablement imprévisible
• Ne peut être reproduit ou prédit, même en principe
• Convient aux applications de sécurité les plus élevées

Limites:

• Généralement plus lent que les méthodes algorithmiques
• Nécessite du matériel spécialisé
• Le débit de sortie est limité par le processus physique
• La sortie brute peut présenter de légers biais qui nécessitent un post-traitement

---

Générateurs de nombres pseudo-aléatoires (PRNG)

Les générateurs de nombres pseudo-aléatoires utilisent des algorithmes mathématiques déterministes pour produire des séquences de nombres qui réussissent les tests statistiques de caractère aléatoire. Bien qu'ils soient entièrement prévisibles depuis leur état initial, les PRNG bien conçus produisent un résultat pratiquement impossible à distinguer du véritable caractère aléatoire pour la plupart des applications.

Comment fonctionnent les PRNG

Chaque PRNG suit le même modèle de base :

1. Seed : Une valeur initiale (la graine) définit l'état interne du générateur
2. Algorithme : Une fonction mathématique transforme l'état actuel en l'état suivant et produit un nombre de sortie
3. Répéter : Le processus continue, chaque État produisant le suivant

La même graine produit toujours la même séquence. Ceci est en fait utile pour la reproductibilité des simulations et des tests.

Algorithmes PRNG courants

Générateur congruentiel linéaire (LCG) : L'un des PRNG les plus anciens et les plus simples. Utilise la formule : next = (a * current + c) mod m. Rapide mais présente des faiblesses connues, notamment des périodes courtes et des modèles prévisibles dans les bits inférieurs. Le rand() de la bibliothèque standard C utilise traditionnellement un LCG.

Mersenne Twister (MT19937) : Le PRNG à usage général le plus largement utilisé. Il a une période de 2 ^ 19937 - 1 (un nombre de 6 002 chiffres), réussit la plupart des tests statistiques et constitue le PRNG par défaut dans Python, Ruby, R, MATLAB et de nombreux autres langages. Cependant, il n’est pas sécurisé du point de vue cryptographique : l’observation de 624 sorties consécutives permet une prédiction complète de toutes les sorties futures.

Famille Xorshift (xoshiro, xoroshiro) : PRNG modernes et rapides qui utilisent des opérations XOR et Shift au niveau du bit. Ils offrent une excellente qualité statistique avec une vitesse très élevée, ce qui les rend populaires pour les jeux et les simulations. Développé par Sebastiano Vigna et David Blackman.

PCG (Permuted Congruential Generator) : Une famille de PRNG conçue par Melissa O'Neill qui combine un LCG avec une fonction de permutation. Les générateurs PCG sont rapides, ont de bonnes propriétés statistiques et sont relativement petits en termes de taille d'état.

Quand les PRNG sont suffisants

Les PRNG sont appropriés lorsque vous avez besoin de :

• Vitesse (millions ou milliards de nombres par seconde)
• Reproductibilité (même graine = même séquence)
• Qualité statistique sans sécurité cryptographique
• Simulation, jeux, méthodes de Monte Carlo ou échantillonnage statistique

---

PRNG cryptographiquement sécurisés (CSPRNG)

Un CSPRNG comble le fossé entre le véritable hasard et la vitesse algorithmique. Il s'agit d'un PRNG doté de garanties de sécurité supplémentaires qui le rendent adapté aux applications cryptographiques.

Exigences de sécurité

Un CSPRNG doit satisfaire deux propriétés :

1. Test du bit suivant : Étant donné les k premiers bits d'une séquence aléatoire, il n'existe aucun algorithme en temps polynomial capable de prédire le bit k+1 avec une probabilité nettement supérieure à 50 %.

2. Résistance d'extension de compromission d'état : Même si un attaquant apprend l'état interne actuel du générateur, il ne peut pas déterminer les sorties précédentes (sécurité arrière).

Comment les CSPRNG obtiennent l'entropie

Les CSPRNG sont ensemencés avec un véritable caractère aléatoire collecté à partir de plusieurs sources matérielles :

• Synchronisation du clavier et de la souris : Variations de l'ordre de la microseconde dans la synchronisation des entrées utilisateur
• Synchronisation des E/S disque : Variations des temps de recherche du disque dur et des modèles d'accès au SSD
• Heures d'arrivée des paquets réseau : Gigue temporelle dans le trafic réseau
• Synchronisation des instructions CPU : Variations par rapport aux effets de cache et à la prédiction de branchement
• Instructions RNG matérielle : Les processeurs modernes (Intel RDRAND, AMD) incluent des sources d'entropie matérielle dédiées
• Minutage des interruptions : Variations du moment où les interruptions matérielles se produisent

Le système d'exploitation collecte cette entropie dans un « pool d'entropie » qui alimente le CSPRNG. Sous Linux, il s'agit de /dev/urandom. Sous Windows, il s'agit de CryptGenRandom. Dans les navigateurs, crypto.getRandomValues() de l'API Web Crypto accède au pool d'entropie du système d'exploitation.

CSPRNG courants

AES-CTR DRBG : utilise le chiffrement par bloc AES en mode compteur comme PRNG. Il s'agit de la valeur par défaut recommandée par le NIST et elle est largement déployée.

ChaCha20 : Un chiffrement de flux par Daniel J. Bernstein, utilisé comme CSPRNG sous Linux (depuis le noyau 4.8), FreeBSD et de nombreuses applications. Il est rapide en logiciel et résistant aux attaques par canal secondaire.

Fortuna : Conçu par Bruce Schneier et Niels Ferguson, Fortuna utilise plusieurs pools d'entropie et réamorce automatiquement à partir de l'entropie du système. Il est utilisé sous macOS et iOS.

---

Comment les ordinateurs génèrent des nombres aléatoires

Traceons le chemin complet depuis l'entropie physique jusqu'au nombre aléatoire que vous voyez à l'écran.

Le pipeline d'entropie

1. Les événements matériels génèrent de l'entropie brute (pressions sur les touches, mouvements de la souris, synchronisation du disque, bruit thermique provenant du RNG matériel du processeur)
2. Le pool d'entropie du système d'exploitation collecte et mélange l'entropie provenant de plusieurs sources, conservant ainsi une estimation du caractère aléatoire disponible.
3. Le CSPRNG est issu du pool d'entropie et utilise un algorithme cryptographique pour étendre une petite quantité de véritable caractère aléatoire en un large flux de bits pseudo-aléatoires cryptographiquement sécurisés.
4. L'application appelle l'API aléatoire du système pour obtenir des nombres au format et dans la plage souhaités.

Valeurs de départ

Une graine est l'état initial qui démarre un PRNG. La qualité de la graine détermine directement la qualité du résultat :

• Mauvaise graine : L'utilisation de l'heure actuelle comme graine (courant dans les systèmes plus anciens) signifie que toute personne connaissant approximativement le moment où le générateur a démarré peut réduire considérablement l'espace de graine.
• Bonne graine : Une valeur de 256 bits provenant d'un CSPRNG fournit 2^256 états de départ possibles, soit plus que le nombre d'atomes dans l'univers observable.
• Gemme reproductible : En calcul scientifique, le choix délibéré d'une graine fixe permet de reproduire exactement les expériences, ce qui est précieux pour le débogage et la vérification.

Distribution uniforme

La plupart des RNG produisent des entiers uniformément distribués : chaque valeur de la plage a une probabilité égale. La conversion vers d'autres distributions nécessite des calculs supplémentaires :

• Distribution normale (gaussienne) : La transformée de Box-Muller convertit deux nombres aléatoires uniformes en deux nombres normalement distribués
• Distribution exponentielle : Appliquer le CDF inverse : -ln(1 - U) / lambda où U est uniforme [0,1)
• Distributions personnalisées : Utilisez la méthode de transformation inverse ou l'échantillonnage par rejet

---

Applications des nombres aléatoires

Jeux

Les jeux vidéo utilisent largement des nombres aléatoires : taux de perte de butin, chances de coup critique, génération procédurale du monde, prise de décision par l'IA, mélange de cartes, lancer de dés et sélection des points d'apparition. La plupart des jeux utilisent des PRNG rapides comme xoshiro256**, car la vitesse compte plus que la sécurité cryptographique.

Cryptographie

Le hasard est le fondement de la cryptographie moderne. Des nombres aléatoires sont nécessaires pour :

• Clés de cryptage : AES-256 nécessite une clé véritablement aléatoire de 256 bits
• Vecteurs d'initialisation (IV) : Empêcher les textes en clair identiques de produire des textes chiffrés identiques
• Nonces : Valeurs uniques utilisées dans les protocoles d'authentification
• Valeurs Salt : Données aléatoires ajoutées aux mots de passe avant le hachage
• Jetons de session : Identifiants imprévisibles pour les sessions Web

Toute faiblesse du générateur de nombres aléatoires utilisé pour la cryptographie peut compromettre l’ensemble du système de sécurité.

Statistiques et sciences

• Simulations Monte Carlo : Estimez des quantités mathématiques complexes par échantillonnage aléatoire (utilisées en physique, finance, ingénierie)
• Rééchantillonnage bootstrap : Technique statistique qui rééchantillonne les données avec remplacement pour estimer les intervalles de confiance
• Essais contrôlés randomisés : Affectation aléatoire des participants aux groupes de traitement et aux groupes témoins
• Modélisation stochastique : Les prévisions météorologiques, l'épidémiologie et les marchés financiers utilisent tous la génération de nombres aléatoires.

Conformité des loteries et des jeux

Les systèmes de loterie légale nécessitent des RNG certifiés qui répondent à des normes strictes. La plupart des juridictions exigent soit des TRNG matériels, soit des CSPRNG minutieusement testés et audités. Les tests impliquent généralement d'exécuter le générateur via des suites de tests statistiques (NIST SP 800-22, Dieharder, TestU01) qui vérifient que la sortie ne montre aucun modèle détectable.

---

Échecs aléatoires célèbres

L’histoire montre que se tromper sur le hasard peut avoir de graves conséquences.

Dual_EC_DRBG : la porte dérobée de la NSA

En 2006, le NIST a standardisé Dual_EC_DRBG (Dual Elliptic Curve Deterministic Random Bit Generator) en tant que CSPRNG approuvé. Les cryptographes ont rapidement remarqué qu'il était étrangement lent et qu'il contenait des constantes inexpliquées qui pourraient fonctionner comme une porte dérobée. En 2013, les documents d'Edward Snowden ont confirmé que la NSA avait délibérément inséré une porte dérobée, leur permettant de prédire le résultat de n'importe quel système en utilisant les constantes par défaut. RSA Security l'avait utilisé par défaut dans sa boîte à outils BSAFE, et le NIST a retiré la norme en 2014.

Leçon : La transparence dans la conception des algorithmes est importante. Les constantes doivent avoir des origines vérifiables et sans prétention.

Rand() et mt_rand() de PHP

La fonction rand() de PHP utilisait historiquement un LCG faible avec un petit état, ce qui le rendait trivialement prévisible. Le remplacement mt_rand() (Mersenne Twister) a amélioré la qualité statistique mais est resté non cryptographique. Les attaquants ont exploité mt_rand() dans les applications Web pour prédire les jetons de session, les jetons CSRF et les liens de réinitialisation de mot de passe. Après avoir observé suffisamment de résultats, l’état interne a pu être entièrement rétabli.

Leçon : N'utilisez jamais de PRNG à usage général pour des applications sensibles en matière de sécurité. Utilisez random_int() ou random_bytes() en PHP, qui utilisent le système d'exploitation CSPRNG.

Le bogue Debian OpenSSL (2008)

En 2006, un responsable de Debian a commenté deux lignes de code dans le générateur de nombres aléatoires d'OpenSSL qu'un outil d'analyse de code a signalé comme utilisant de la mémoire non initialisée. Ces lignes étaient en fait la principale source d’entropie. Pendant deux ans, chaque clé SSL, clé SSH et autre clé cryptographique générée sur les systèmes Debian et Ubuntu avait au plus 32 768 valeurs possibles au lieu du nombre astronomique prévu. Toute clé générée pendant cette période pourrait être devinée en quelques secondes.

Leçon : Les modifications apportées au code cryptographique nécessitent un examen par un expert. Les outils automatisés peuvent signaler les comportements légitimes comme des bogues.

Le piratage ECDSA de la PlayStation 3 (2010)

La signature de code PlayStation 3 de Sony utilisait ECDSA (Elliptic Curve Digital Signature Algorithm), qui nécessite un nouveau nom occasionnel aléatoire pour chaque signature. Sony a utilisé le même nom occasionnel pour chaque signature. Cette erreur mathématique a permis aux pirates de récupérer la clé de signature privée de Sony, permettant ainsi l'installation de logiciels non autorisés sur n'importe quelle PS3.

Leçon : La réutilisation de valeurs aléatoires dans des protocoles cryptographiques peut s'avérer catastrophique. Les noms occasionnels doivent être uniques.

La catastrophe de RANDU (années 1960)

Le générateur RANDU d'IBM, largement utilisé dans le calcul scientifique dans les années 1960 et 1970, présentait un grave défaut : lorsqu'il était tracé en trois dimensions, sa sortie tombait sur seulement 15 plans parallèles au lieu de remplir l'espace uniformément. D'innombrables simulations scientifiques et articles de recherche publiés à cette époque ont utilisé RANDU, et leurs résultats ont peut-être été compromis par ce caractère non aléatoire. Le générateur a été si largement diffusé que certaines études concernées n'ont jamais été identifiées ou corrigées.

Leçon : Les tests statistiques des générateurs de nombres aléatoires sont essentiels. L'inspection visuelle (traçage en plusieurs dimensions) peut révéler des modèles qui échappent aux simples tests unidimensionnels.

---

Génération de nombres aléatoires en programmation

JavaScript

// Basic random integer between min and max (inclusive)
function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandomInt(1, 100)); // e.g., 42

// Cryptographically secure random integer
function getSecureRandomInt(min, max) {
  const range = max - min + 1;
  const bytesNeeded = Math.ceil(Math.log2(range) / 8);
  const maxValid = Math.floor(256 ** bytesNeeded / range) * range - 1;
  let value;
  do {
    const array = new Uint8Array(bytesNeeded);
    crypto.getRandomValues(array);
    value = array.reduce((acc, byte, i) => acc + byte * (256 ** i), 0);
  } while (value > maxValid);
  return min + (value % range);
}

// Generate array of unique random numbers (no repeats)
function getUniqueRandomNumbers(min, max, count) {
  const range = Array.from({ length: max - min + 1 }, (_, i) => min + i);
  // Fisher-Yates shuffle
  for (let i = range.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [range[i], range[j]] = [range[j], range[i]];
  }
  return range.slice(0, count);
}
console.log(getUniqueRandomNumbers(1, 49, 6)); // e.g., [7, 23, 41, 3, 38, 15]

// Simulate dice rolls
function rollDice(sides = 6, count = 1) {
  return Array.from({ length: count }, () => getRandomInt(1, sides));
}
console.log(rollDice(6, 3)); // e.g., [4, 2, 6]

Python

import random
import secrets

# Basic random integer between 1 and 100
print(random.randint(1, 100))  # e.g., 42

# Cryptographically secure random integer
print(secrets.randbelow(100) + 1)  # 1 to 100

# Generate unique random numbers (no repeats)
lottery = random.sample(range(1, 50), 6)
print(sorted(lottery))  # e.g., [3, 7, 15, 23, 38, 41]

# Reproducible random sequence with a seed
random.seed(42)
print([random.randint(1, 100) for _ in range(5)])
# Always: [82, 15, 4, 95, 36]

# Shuffle a list in place
deck = list(range(1, 53))
random.shuffle(deck)
print(deck[:5])  # e.g., [37, 12, 49, 3, 28]

# Weighted random selection
choices = ['common', 'uncommon', 'rare', 'legendary']
weights = [70, 20, 8, 2]
result = random.choices(choices, weights=weights, k=10)
print(result)

# Cryptographically secure token
token = secrets.token_hex(32)  # 64-character hex string
print(token)

# Secure random password
import string
alphabet = string.ascii_letters + string.digits + string.punctuation
password = ''.join(secrets.choice(alphabet) for _ in range(16))
print(password)

Principales différences entre les langues

Fonctionnalité	JavaScript	Python
PRNG de base	Math.random()	random.random()
Plage entière	Math.floor(Math.random() * n)	random.randint(a, b)
Crypto-sécurisé	crypto.getRandomValues()	secrets.token_bytes()
Semable	Non (Math.random)	Oui (random.seed())
Échantillonnage sans répétition	Manuel Fisher-Yates	random.sample()

---

Probabilité et équité

Distribution uniforme

Un générateur de nombres aléatoires équitable produit une distribution uniforme : chaque valeur possible a exactement la même probabilité d'être sélectionnée. Pour une plage de 1 à 100, chaque numéro devrait apparaître environ 1 % du temps sur plusieurs tirages.

Tester le caractère aléatoire

Comment vérifier qu’un générateur produit réellement de bons nombres aléatoires ? Plusieurs suites de tests standards existent :

NIST SP 800-22 : La suite de tests de l'Institut national américain des normes et de la technologie comprend 15 tests statistiques : test de fréquence, test d'exécution, test d'exécution la plus longue, test FFT, test en série et autres. Utilisé pour certifier les CSPRNG.

Dieharder : Une suite complète de plus de 31 tests statistiques développés par Robert G. Brown de l'Université Duke. Les tests incluent les espacements d'anniversaire, les permutations qui se chevauchent, le test de parking et le test de compression.

TestU01 : Développé par Pierre L'Ecuyer de l'Université de Montréal, TestU01 inclut la batterie "Big Crush" de 160 tests statistiques. Elle est considérée comme la suite de tests à usage général la plus stricte pour les PRNG.

Le paradoxe de l'anniversaire et les collisions

Lors de la génération de nombres aléatoires, les collisions (valeurs répétées) se produisent plus tôt que prévu. Dans un groupe de seulement 23 personnes, il y a 50 % de chances que deux personnes partagent le même anniversaire (sur 365 jours possibles). De la même manière:

• En générant des entiers aléatoires de 32 bits, vous pouvez vous attendre à une collision après environ 77 000 nombres
• Pour les entiers de 64 bits, les collisions apparaissent après environ 5 milliards de nombres
• Pour les valeurs 128 bits, les collisions apparaissent après environ 2 ^ 64 (18 quintillions) de valeurs

Cela est important pour générer des identifiants uniques. Les UUID (128 bits) sont suffisamment grands pour que les collisions soient pratiquement impossibles, mais des ID aléatoires plus courts peuvent entrer en collision plus tôt que prévu.

Biais dans la génération de nombres aléatoires

Un problème subtil survient lors du mappage de la sortie d'un PRNG sur une plage spécifique. Si le PRNG produit des valeurs 0 à 255 et que vous souhaitez des nombres 1 à 100, l'utilisation de value % 100 + 1 introduit un léger biais : les valeurs 1 à 56 sont légèrement plus probables que 57 à 100 car 256 n'est pas divisible de manière égale par 100. L'approche correcte est l'échantillonnage par rejet : éliminez les valeurs qui provoqueraient un biais et régénérez-les.

---

Foire aux questions

Math.random() en JavaScript est-il sûr pour les mots de passe ?

Non. Math.random() est un PRNG rapide (généralement xorshift128+ dans les moteurs modernes) qui n'est pas sécurisé cryptographiquement. Son état interne peut être récupéré à partir des sorties observées. Pour les mots de passe, les jetons ou tout autre objectif de sécurité, utilisez crypto.getRandomValues() ou l'API Web Crypto.

Comment les machines à sous génèrent-elles des résultats aléatoires ?

Les machines à sous modernes utilisent des CSPRNG certifiés qui génèrent en permanence des nombres aléatoires (généralement des milliers par seconde), même lorsque personne ne joue. Le moment exact où un joueur appuie sur le bouton de rotation détermine quel nombre aléatoire est utilisé, qui correspond à une configuration de rouleau spécifique. Les commissions de jeu testent et certifient ces RNG pour garantir l’équité.

Un ordinateur quantique peut-il briser les générateurs de nombres aléatoires ?

Les ordinateurs quantiques ne peuvent pas briser les TRNG car le véritable caractère aléatoire des phénomènes physiques reste imprévisible, quelle que soit la puissance de calcul. Cependant, les ordinateurs quantiques pourraient théoriquement briser certains CSPRNG si les primitives cryptographiques sous-jacentes (comme l'AES ou les courbes elliptiques) devenaient vulnérables. Des conceptions CSPRNG post-quantiques sont en cours de développement pour résoudre ce problème.

Quelle est la différence entre Math.random() et crypto.getRandomValues() ?

Math.random() renvoie un nombre à virgule flottante compris entre 0 et 1 à l'aide d'un algorithme rapide mais non sécurisé. Il convient aux jeux et aux simulations. crypto.getRandomValues() remplit un tableau typé avec des valeurs aléatoires cryptographiquement fortes provenant du pool d'entropie du système d'exploitation. Il convient aux applications sensibles en matière de sécurité mais légèrement plus lent.

Comment générer un nombre aléatoire avec une distribution normale (courbe en cloche) ?

Utilisez la transformée de Box-Muller : générez deux nombres aléatoires uniformes U1 et U2 compris entre 0 et 1, puis calculez Z = sqrt(-2 * ln(U1)) * cos(2 * pi * U2). Z suivra une distribution normale standard (moyenne 0, écart type 1). Évoluez et modifiez selon les besoins : result = mean + Z * standardDeviation.

Pourquoi ne devriez-vous jamais utiliser l’heure actuelle comme valeur aléatoire pour des raisons de sécurité ?

L’heure actuelle est prévisible. Un attaquant qui sait approximativement quand une clé a été générée peut essayer tous les horodatages possibles dans cette fenêtre. Même avec une précision à la milliseconde près, il n’existe qu’environ 86 400 000 graines possibles par jour – facilement consultables par un ordinateur moderne. Les applications sensibles à la sécurité doivent utiliser l'entropie des sources matérielles via le système d'exploitation CSPRNG.

Comment tester si un générateur de nombres aléatoires est équitable ?

Exécutez le générateur plusieurs fois (au moins 10 000 itérations) et vérifiez que la distribution des résultats correspond à la distribution attendue. Pour un générateur uniforme produisant les valeurs 1 à 6, chaque valeur doit apparaître environ 1/6 du temps. Appliquez des tests du chi carré pour vérifier l’uniformité statistique. Pour des tests plus rigoureux, utilisez des suites de tests standardisés comme NIST SP 800-22 ou Big Crush de TestU01, qui appliquent des dizaines de tests statistiques couvrant l'analyse de fréquence, la corrélation série, les exécutions les plus longues, l'analyse spectrale, etc.