Pseudo-aléatoires et véritablement aléatoires sont-ils différents et pourquoi est-ce important?
Je n'ai jamais vraiment eu ça. Dites simplement que vous écrivez un petit programme dans n'importe quelle langue qui lance des dés (en utilisant les dés comme exemple). Après 600 000 lancers, chaque nombre aurait été roulé environ 100 000 fois, ce à quoi je m'attendais.
Pourquoi existe-t-il des sites Web dédiés au «vrai hasard»? Étant donné l'observation ci-dessus, les chances d'obtenir n'importe quel nombre sont presque exactement égales à 1, quel que soit le nombre de nombres qu'il peut choisir.
Je l'ai essayé dans Python : Voici le résultat de 60 millions de rouleaux. La variation la plus élevée est de 0,15. N'est-ce pas aussi aléatoire que cela va arriver?
1 - 9997653 2347.0
2 - 9997789 2211.0
3 - 9996853 3147.0
4 - 10006533 -6533.0
5 - 10002774 -2774.0
6 - 9998398 1602.0
Comme le dit Eric Lippert, il ne s’agit pas que de la distribution. Il existe d'autres moyens de mesurer le caractère aléatoire.
L'un des premiers générateurs de nombres aléatoires a une séquence dans le bit le moins significatif - il alterne les 0 et les 1. Par conséquent, le LSB était prévisible à 100%. Mais vous devez vous soucier de plus que cela. Chaque bit doit être imprévisible.
Voici un bon moyen de réfléchir au problème. Disons que vous générez 64 bits de hasard. Pour chaque résultat, prenez les 32 premiers bits (A) et les 32 derniers bits (B), et créez un index dans un tableau x [A, B]. Effectuez maintenant le test un million de fois et, pour chaque résultat, incrémentez le tableau à ce nombre, c’est-à-dire X [A, B] ++;
Dessinez maintenant un diagramme 2D, où plus le nombre est grand, plus le pixel est lumineux à cet endroit.
Si c'est vraiment aléatoire, la couleur devrait être un gris uniforme. Mais vous pourriez avoir des modèles. Prenez par exemple ce diagramme du "caractère aléatoire" dans le numéro de séquence TCP du système Windows NT:
ou même celui-ci sous Windows 98:
Et voici le caractère aléatoire de la mise en œuvre du routeur Cisco (IOS). 
Ces diagrammes sont une gracieuseté de le papier de Michał Zalewski . Dans ce cas particulier, si on peut prédire ce que le TCP numéro de séquence sera d'un système, on peut emprunter l'identité de ce système lors de la connexion à un autre système - ce qui permettrait le détournement de connexions, l'interception de communications, etc. Et même si nous ne pouvons pas prédire le nombre suivant 100% du temps, si nous pouvons provoquer la création d'une nouvelle connexion sous notre contrôle , nous pouvons augmenter les chances de succès. Et lorsque des ordinateurs peuvent générer 100 000 connexions en quelques secondes, les chances d’une attaque réussie vont d’astronomiques à possibles ou même probables.
Bien que les nombres pseudo-aléatoires générés par les ordinateurs soient acceptables pour la majorité des cas d'utilisation rencontrés par les utilisateurs d'ordinateurs, il existe des scénarios qui nécessitent des nombres aléatoires complètement / imprévisibles.
Dans les applications sensibles à la sécurité telles que le cryptage, un générateur de nombres pseudo-aléatoires (PRNG) peut produire des valeurs qui, bien qu'aspect d'apparence aléatoire, sont en fait prévisibles par un attaquant. Une personne essayant de déchiffrer un système de chiffrement peut être en mesure de deviner les clés de chiffrement si un PRNG a été utilisé et si l'attaquant dispose d'informations sur l'état du PRNG. Par conséquent, pour de telles applications, un générateur de nombre aléatoire qui produit des valeurs qui sont vraiment impossibles à deviner est nécessaire. Notez que certains PRNG sont conçus pour être sécurisés par cryptographie et sont utilisables pour de telles applications sensibles à la sécurité.
Plus d'informations sur les attaques RNG peuvent être trouvées dans cet article Wikipedia .
Je l'ai essayé en Python: voici le résultat de 60 millions de rouleaux. La variation la plus élevée est de 0,15. N'est-ce pas aussi aléatoire que cela va arriver?
En fait, c’est donc "bien" c’est mauvais ... Toutes les réponses existantes se concentrent sur prévisibilité étant donné une petite séquence de valeurs initiales. Je veux soulever un autre problème:
votre distribution a un écart-type beaucoup plus petit que les jets aléatoires ne devraient
Le véritable caractère aléatoire ne vient tout simplement pas assez que presque en moyenne "presque exactement 1 sur le nombre de nombres qu'il peut choisir" que vous utilisez comme indicateur de qualité.
Si vous regardez cette question de Stack Exchange sur les distributions de probabilité pour plusieurs lancers de dés , vous verrez une formule pour l'écart type de N lancers de dés (en supposant des résultats réellement aléatoires):
sqrt(N * 35.0 / 12.0).
En utilisant cette formule, écart type pour:
- 1 million de lancers est 1708
- 60 millions de lancers, c'est 13229
Si on regarde vos résultats:
- 1 million de lancers: stddev (1000066, 999666, 1001523, 999452, 999294, 999999) est 804
- 60 millions de rouleaux: stddev (9997653, 9997789, 9996853, 10006533, 10002774, 9998398) est 3827
Vous ne pouvez pas vous attendre à ce que l'écart type d'un échantillon fini corresponde exactement à la formule, mais il devrait être très proche. Pourtant, avec un million de lancers, vous avez moins de la moitié de la valeur normale, et par 60 millions, vous avez moins d'un tiers - la situation empire et ce n'est pas un hasard ...
Les pseudo-RNG ont tendance à se déplacer dans une séquence de nombres distincts, en commençant par la graine et en ne revenant pas sur le numéro d'origine pour une période spécifique. Par exemple, les implémentations de l'ancienne fonction Rand() de la bibliothèque C ont généralement une période de 2 ^ 32, et elles visitent chaque nombre entre 0 et 2 ^ 32-1 exactement une fois avant de répéter la graine. Donc, si vous simuliez 2 ^ 32 jets de dés, les résultats de pré-module (%) incluraient chaque nombre compris entre 0 et 2 ^ 32, les décomptes pour chaque résultat 1-6 seraient 715827883 ou 715827882 (2 ^ 32 n'est pas un multiple de 6), et l’écart type n’est donc que trivialement supérieur à 0. En utilisant la formule ci-dessus, l’écart type correct pour les 2 ^ 32 lancers est 111924. Quoi qu’il en soit, lorsque votre nombre d’appel pseudo-aléatoires augmente, vous convergez vers l’écart type. On peut s’attendre à ce que le problème soit important lorsque le nombre de rôles représente une fraction importante de la période, mais certains pseudo-GNA peuvent présenter des problèmes plus graves que d’autres, voire des problèmes, même avec moins d’échantillons.
Ainsi, même si vous ne vous souciez pas des vulnérabilités cryptographiques, dans certaines applications, vous pouvez vous préoccuper des distributions qui n'ont pas trop, artificiellement même des résultats. Certains types de simulation tentent plus particulièrement de déterminer les conséquences des résultats {inégaux} qui se produisent naturellement avec de grands échantillons de résultats aléatoires individuels, mais ils sont sous-représentés dans certains résultats de pRNG. Si vous essayez de simuler la réaction d’une énorme population à un événement donné, ce problème pourrait radicalement altérer vos résultats, ce qui aboutirait à des conclusions extrêmement fausses.
Pour donner un exemple concret, disons qu'un mathématicien dit à un programmeur de machine de poker qu'après 60 millions de rouleaux simulés - utilisés pour scintiller des centaines de petites "lumières" autour de l'écran, s'il y a eu 10 013 229 ou plus, ce que le mathématicien s'attend à être 1 stddev loin de la moyenne, il devrait y avoir un petit paiement. Conformément à la règle 68–95–99.7 (Wikipedia) cela devrait se produire environ 16% du temps (~ 68% se situent dans un écart-type/seule la moitié des réponses se situent au-dessus). Avec votre générateur de nombres aléatoires, cela représente environ 3,5 écarts types au-dessus de la moyenne: Moins de 0,025% chance - pratiquement aucun client ne bénéficie de cet avantage. Voir le tableau Déviations plus élevées sur la page que je viens de mentionner, plus précisément:
| Range | In range | Outside range | Approx. freq. for daily event |
| µ ± 1σ | 0.68268... | 1 in 3 | Twice a week |
| µ ± 3.5σ | 0.99953... | 1 in 2149 | Every six years |
Je viens d'écrire ce générateur de nombres aléatoires pour générer des jets de dés
def get_generator():
next = 1
def generator():
next += 1
if next > 6:
next = 1
return next
return generator
Vous l'utilisez comme ça
>> generator = get_generator()
>> generator()
1
>> generator()
2
>> generator()
3
>> generator()
4
>> generator()
5
>> generator()
6
>> generator()
1
etc etc. Seriez-vous heureux d'utiliser ce générateur pour un programme qui exécute un jeu de dés? N'oubliez pas que sa distribution correspond exactement à ce que vous attendez d'un générateur "vraiment aléatoire"!
Les générateurs de nombres pseudo-aléatoires font essentiellement la même chose: ils génèrent des nombres prévisibles avec la distribution correcte. Ils sont mauvais pour la même raison que le générateur de nombres aléatoires simpliste ci-dessus est mauvais - ils ne conviennent pas aux situations dans lesquelles vous avez besoin d'une véritable imprévisibilité, pas seulement de la distribution correcte.
La génération de nombres aléatoires que votre ordinateur peut effectuer convient à la plupart des besoins, et il est peu probable que vous rencontriez un moment où vous avez besoin d'un nombre véritablement aléatoire.
La véritable génération de nombres aléatoires a cependant ses objectifs. En sécurité informatique, jeu, échantillonnage statistique volumineux, etc.
Si vous êtes intéressé par les applications de nombres aléatoires, consultez le article Wikipedia .
Les nombres aléatoires générés par des fonctions typiques dans la plupart des langages de programmation ne sont pas purement des nombres aléatoires. Ce sont des nombres pseudo aléatoires. Puisqu'ils ne sont pas des nombres purement aléatoires, ils peuvent être devinés avec suffisamment d'informations sur les nombres précédemment générés. Ce sera donc un désastre pour la sécurité en cryptographie .
Par exemple, la fonction de générateur de nombre aléatoire suivante utilisée dans glibc ne génère pas un nombre purement aléatoire. Le nombre pseudo aléatoire généré par ceci peut être deviné. C'est une gaffe pour les problèmes de sécurité. Il y a une histoire de cela en train de devenir désastreux. Cela ne devrait pas être utilisé en cryptographie.
glibc random():
r[i] ← ( r[i-3] + r[i-31] ) % (2^32)
output r[i] >> 1
Ce type de générateur de nombres pseudo-aléatoires ne devrait jamais être utilisé dans des endroits sensibles à la sécurité, même s'il est statistiquement significatif.
Une des attaques les plus connues sur les clés pseudo aléatoires est l'attaque sur 802.11b WEP . WEP a une clé à long terme de 104 bits, concaténée avec un IV (compteur) de 24 bits pour créer une clé de 128 bits, qui est à son tour appliquée à algorithme RC4 pour générer une clé pseudo aléatoire.
( RC4( IV + Key ) ) XOR (message)
Les clés étaient étroitement liées les unes aux autres. Ici, seule la IV augmentée de 1 à chaque étape et toutes les autres sont restées les mêmes. Comme ce n'était pas purement aléatoire, c'était désastreux et facile à décomposer. La clé pourrait être récupérée en analysant environ 40000 images, soit quelques minutes. Si le WEP utilisait une IV purement aléatoire à 24 bits, il pourrait être sécurisé jusqu'à environ 2 ^ 24 (près de 16,8 millions) de trames.
Il faut donc utiliser le générateur de nombres aléatoires purs dans les questions sensibles de sécurité, lorsque cela est possible.
La différence est que les nombres générés pseudo-aléatoires sont prévisibles (se répètent) après un certain temps où les vrais nombres aléatoires ne le sont pas. La longueur nécessaire pour répéter dépend de la longueur de la graine utilisée pour sa génération.
Voici une jolie vidéo de Nice sur ce sujet: http://www.youtube.com/watch?v=itaMNuWLzJo
Le premier nombre aléatoire que j'ai jamais utilisé avait l'excellente propriété que de deux nombres aléatoires consécutifs, le second était plus grand avec une probabilité de 0,6. Pas 0.5. Et le troisième était plus grand que le second avec une probabilité de 0,6, et ainsi de suite. Vous pouvez imaginer à quel point cela simule une simulation.
Certaines personnes ne me croiraient pas que c'était même possible avec les nombres aléatoires distribués de manière égale, mais c'est évidemment possible si vous regardez la séquence (1, 3, 5, 2, 4, 1, 3, 5, 2, 4, ...) où le deuxième des deux nombres est plus grand avec une probabilité de 0,6.
D'autre part, pour les simulations, il peut être important de pouvoir reproduire des nombres aléatoires. Supposons que vous effectuez une simulation de trafic et que vous souhaitiez savoir comment certaines actions que vous pourriez entreprendre pourraient améliorer le trafic. Dans ce cas, vous souhaitez pouvoir recréer exactement les mêmes données de trafic (comme des personnes essayant d'entrer dans une ville) avec différentes actions pour améliorer le trafic.
Supposons qu'un nombre pseudo aléatoire puisse être deviné par quiconque avant qu'il ne soit généré.
Pour les applications triviales, un pseudo-hasard convient, car avec votre exemple, vous obtiendrez approximativement le pourcentage correct (environ 1/6 du total des résultats) avec une légère variation (que vous verriez si vous lancez un dé 600k fois);
Cependant, lorsqu'il s'agit de choses comme la sécurité informatique; Le véritable caractère aléatoire est requis.
Par exemple, l'algorithme RSA commence lorsque l'ordinateur choisit deux nombres aléatoires (P et Q), puis effectue plusieurs étapes pour générer ces nombres spéciaux, appelés clés publique et clé privée. (La partie importante d'une clé privée est qu'elle est privée et personne d'autre ne le sait!)
Si un attaquant peut savoir quels sont les deux nombres «aléatoires» choisis par votre ordinateur, il peut procéder de la même manière pour calculer votre clé privée (celle que personne d'autre n'est supposé savoir!).
Avec votre clé privée, un attaquant peut: a) Parler à votre banque en se faisant passer pour vous, b) Écouter votre trafic Internet "sécurisé" et pouvoir le décoder, c) Se faire passer pour quelqu'un d'autre sur Internet.
C'est là que le véritable caractère aléatoire (c'est-à-dire ne pas pouvoir être deviné/calculé) est requis.
La réponse courte est que généralement les gens ont besoin du "vrai caractère aléatoire" pour une mauvaise raison, à savoir qu'ils ne comprennent pas la cryptographie.
Les primitives cryptographiques telles que les chiffrements de flux et CSPRNG sont utilisées pour produire d’énormes flux de bits imprévisibles une fois qu’ils ont été alimentés par quelques bits imprévisibles.
Le lecteur attentif aura maintenant compris qu'il existe un problème d'amorçage: nous devons rassembler quelques bits d'entropie pour tout lancer. Ensuite, be peut les envoyer à un CSPRNG qui, à son tour, fournira avec bonheur tous les bits imprévisibles dont nous avons besoin. Ainsi, un générateur de ressources matérielles est nécessaire pour créer un fichier CSPRNG . C’est le seul cas où l’entropie est requise en vérité.
(Je pense que cela aurait dû être posté dans Sécurité ou Cryptographie.)
Éditer: Au final, il faut sélectionner un générateur de nombres aléatoires assez bon pour la tâche envisagée et en ce qui concerne la génération de nombres aléatoires, le matériel ne signifie pas nécessairement bon. Tout comme les mauvais PRNG, les sources aléatoires matérielles ont généralement des biais.
Edit: Certaines personnes ici supposent un modèle de menace dans lequel un attaquant pourrait lire l’état interne d’un CSPRNG et à partir de là, conclure que les CSPRNG ne constituent pas une solution sûre. Ceci est un exemple de mauvaise modélisation de thread. Si un attaquant possède votre système, le jeu est terminé, simplement. Que vous utilisiez un TRNG ou un CSPRNG à ce stade ne fait aucune différence.
Edit: Donc, pour résumer tout cela… Entropie est nécessaire pour ensemencer un CSPRNG. Une fois cela fait, un CSPRNG fournira tous les bits imprévisibles dont nous avons besoin pour les applications de sécurité beaucoup plus rapidement que nous ne pouvons (généralement) collecter l'entropie. Si l'imprévisibilité n'est pas nécessaire, comme pour la simulation, un Twister Mersenne fournira des nombres avec de bonnes propriétés statistiques à un taux beaucoup plus élevé.
Edit: Toute personne désireuse de comprendre le problème de la génération sécurisée de nombres aléatoires devrait lire ceci: http://www.cigital.com/whitepapers/dl/The_Importance_of_Reliable_Randomness.pdf
Tous les PRNG ne conviennent pas à toutes les utilisations. Par exemple, Java.util.SecureRandom utilise le hachage SHA1, dont la taille de sortie est de 160 bits. Cela signifie qu'il y a 2160 flux possibles de nombres aléatoires qui peuvent en découler. Aussi simple que cela. Vous ne pouvez pas obtenir plus de 2160 valeurs de l'état interne. Ainsi, vous ne pouvez pas obtenir plus de 2160 flux uniques de nombres aléatoires à partir d'une seule graine, peu importe d'où vient votre graine. Windows CryptGenRandom est censé utiliser un état de 40 octets, il a 2320 flux possibles de nombres aléatoires.
Le nombre de façons de mélanger un paquet standard de 52 cartes est de 52 !, ce qui correspond à environ 2226. Ainsi, quel que soit l'ensemencement, vous ne pouvez pas utiliser Java.util.SecureRandom pour mélanger un jeu de cartes. Il y a environ 266 mélanges possibles qu'il ne peut pas produire. Bien sûr, nous ne savons pas lesquels ils sont ...
Donc, si j'avais une source de 256 bits de véritable caractère aléatoire (par exemple, à partir d'une carte Quantis RNG), je pourrais créer un fichier PRNG comme CryptGenRandom () avec ce fichier, puis utiliser le fichier PRNG pour mélanger un jeu de cartes. Si je réensemence avec un véritable hasard chaque mélange, tout ira bien: imprévisible et statistiquement aléatoire. Si je faisais la même chose avec Java.util.SecureRandom, il y aurait des remaniements impossibles à produire car il ne peut pas être semé avec 256 bits d'entropie et son état interne ne peut pas représenter tous les remaniements possibles.
Notez que les résultats Java.util.SecureRandom seraient à la fois imprévisibles et statistiquement aléatoires. Aucun test statistique ne permettrait jamais d'identifier un problème! Mais la sortie du RNG n’est pas assez grande pour couvrir l’ensemble des sorties possibles pour simuler un jeu de cartes.
Et rappelez-vous, si vous ajoutez les jokers, c'est 54! que vous devez couvrir, ce qui nécessite environ 2238 possibilités.
La différence entre "vrai" nombre aléatoire et "pseudo" nombre aléatoire est la prévisibilité. Cette réponse a déjà été fournie.
Cependant, la prévisibilité n'est pas nécessairement une mauvaise chose, comme le montrent la plupart des exemples. Voici un exemple pratique d’un des rares cas où la prévisibilité est bonne: le système de positionnement global.
Chaque satellite utilise un code PRN distinct (les codes Gold ) adapté à la corrélation automatique ou à la corrélation croisée nécessaire pour la mesure du temps de propagation du signal. Pour ces codes de Gold, la corrélation entre eux est particulièrement faible, ce qui permet une identification sans équivoque du satellite, mais permet le calcul de distance par la corrélation entre la séquence émise et le récepteur.
Les nombres pseudo-aléatoires sont générés à l'aide d'une fonction mathématique et d'une valeur initiale (appelée graine ), alors que les nombres aléatoires ne le sont pas. Leur prévisibilité les rend incroyablement utiles pour les répétitions de jeu, car il vous suffit de sauvegarder la graine et l'entrée du joueur - l'IA répondra exactement de la même manière "aléatoire" à chaque fois.
Pour un contrôle rapide de l’aléatoire, vous prenez des points avec des coordonnées aléatoires dans [0; 1), puis vous les mettez dans un cube de dimension k. Ensuite, vous effectuez une procédure pour découper ce cube en sous-cubes - chaque volume de sous-cube (ou sous-sphère) doit être mesuré correctement par cette procédure avec des fluctuations selon le théorème bien connu.
La qualité du hasard est importante lorsque vous vous rencontrez ...
des fins de sécurité. Lorsque vous générez un nombre à utiliser comme paramètre pour votre génération de clé, et que cela est bien prévisible, l'ennemi le détectera avec une probabilité de 100% et réduira le champ de recherche de manière beaucoup plus réduite.
à des fins scientifiques. En science, il faut non seulement avoir la moyenne moyenne en bon état, mais également éliminer les corrélations entre différents nombres aléatoires. Donc, si vous prenez (a_i - a) (a_ {i + 1} -a) et trouvez sa distribution, elle doit correspondre à des statistiques.
La corrélation de paires est appelée "aléatoire faible". Si vous voulez un caractère aléatoire réel, vous devez avoir une corrélation d’ordre élevé avec plus de 2 variances.
Aujourd'hui, seuls les générateurs de la mécanique quantique fournissent un véritable caractère aléatoire.
Pourquoi le vrai hasard est-il important?
Il existe essentiellement deux raisons pour lesquelles le véritable caractère aléatoire est nécessaire:
- Si vous utilisez le RNG pour la cryptographie (y compris des choses comme le jeu en argent réel et une loterie), un PRNG vous rendra le chiffre beaucoup plus faible que son analyse mathématique (qui suppose un TRNG) vous ferait croire . Le PRNG ne sera pas réellement aléatoire, mais aura un motif - les adversaires peuvent exploiter ce motif pour déchiffrer un chiffre qui aurait dû être insaisissable.
- Si vous utilisez le RNG pour simuler des entrées "aléatoires", par exemple pour un test de bogue ou une simulation, un PRNG affaiblit votre approche. Lorsque vous ne découvrirez aucun bug, il y aura toujours ce doute lancinant: existe-t-il un bug qui ne se remarque pas avec le motif de mon PRNG, mais qui se serait présenté si je n'utilisais qu'un TRNG? Les résultats de ma simulation décrivent-ils avec exactitude la réalité ou le phénomène que j'ai découvert est-il simplement un artefact du modèle du PRNG?
En dehors de ces zones, cela n'a pas vraiment d'importance. Avertissement: si votre PRNG est vraiment très mauvais, il se peut qu'il ne soit toujours pas approprié - vous ne voulez pas créer un jeu de Craps où les dés sont toujours identiques, vos joueurs ne l'aimeraient pas.
Comment PRNG de Python n'est-il pas assez bon?
Il est très peu probable que vous puissiez détecter les pièges d'un réel PRNG en utilisant une méthodologie aussi simple. L'analyse statistique des RNG est un domaine scientifique à part entière, et certains tests très sophistiqués sont disponibles pour évaluer le "caractère aléatoire" d'un algorithme. Celles-ci sont beaucoup plus avancées que votre simple tentative.
Tous les développeurs de logiciels qui créent des bibliothèques du monde réel, tels que les développeurs Python, utilisent ces tests statistiques pour déterminer si leur implémentation PRNG est suffisante. Par conséquent, il est très peu probable que vous soyez en mesure de détecter facilement un modèle dans un PRNG du monde réel, sauf dans les cas de supervision réelle par le développeur. Cela ne signifie pas qu'il n'y a pas de modèle - un PRNG a un modèle par définition.
Fondamentalement, vous ne pouvez pas prouver qu'une source est aléatoire par une analyse mathématique de la sortie, vous avez besoin, par exemple. un modèle physique qui dit que la source est aléatoire (comme dans la désintégration radioactive).
Vous pouvez simplement exécuter des tests par lots pour trouver une corrélation statistique dans les données de sortie. Dans ce cas, il est prouvé que les données ne sont pas aléatoires (mais une source aléatoire peut également générer des sorties non aléatoires. Sinon, elle ne sera pas vraiment aléatoire si elle ne peut pas donner de données spécifiques. sortie). Sinon, si les tests sont réussis, vous pouvez dire que les données sont pseudo aléatoires.
Passer quelques tests aléatoires signifie seulement que vous avez un bon PRNG (générateur de nombres pseudo aléatoires), ce qui peut être utile pour les applications où la sécurité n'est pas impliquée.
Si la sécurité est en jeu (chiffrement, génération d'une clé, génération de nombres aléatoires pour le jeu, etc.), il ne suffit pas d'avoir un bon PRNG, il doit posséder des qualités supplémentaires, telles que la sortie de fonction n'est pas Deviné facilement par les sorties précédentes, la fonction doit avoir un coût de calcul souhaitable (suffisamment limité pour être utilisable, mais suffisamment élevée pour empêcher les tentatives de forçage brutal), le matériel qui exécute la fonction - ou le périphérique, dans le cas étrange d'aujourd'hui. un appareil analogique - ne doit pas être facilement altéré, etc.
Avoir un bon PRNG peut être utile dans les jeux pour créer de nouveaux modèles imprévisibles, et dans le cryptage - trop lourd à expliquer dans un seul post, il suffit de penser comme un rôle de base quelle sortie de la procédure de cryptage doit être pseudo -randome, ne montrant pas des modèles qui pourraient associer des données cryptées précédentes avec les données cryptées suivantes, ou associer des données en texte brut à des données cryptées, ou relier deux cryptogrammes différents l'un à l'autre (afin que des suppositions puissent être faites sur les textes en clair) ....