Différence entre java.util.Aléatoire et java.de sécurité.SecureRandom

Le standard d'Oracle JDK 7 mise en œuvre utilise ce qu'on appelle un Générateur Linéaire à Congruence pour produire des valeurs aléatoires dans java.util.Random.

Prises de java.util.Random code source (JDK 7u2), à partir d'un commentaire sur la méthode protected int next(int bits), qui est celui qui génère les valeurs aléatoires:

C'est une congruence linéaire générateur de nombres pseudo-aléatoires, comme
défini par D. H. Lehmer et décrit par Donald E. Knuth dans
The Art of Computer Programming, Volume 3:
Seminumerical Algorithmes, la section 3.2.1.

La prévisibilité de Congruence Linéaire Générateurs

Hugo Krawczyk a écrit un très bon papier sur la façon dont ces LCGs peut être prédite ("Comment prévoir des générateurs à congruence"). Si vous avez de la chance et intéressés, vous pouvez toujours en trouver un gratuit, version téléchargeable sur le web. Et il y a beaucoup plus de recherche montre clairement que vous devriez jamais utiliser une GRILLE pour la sécurité des fins de critique. Cela signifie aussi que vos nombres aléatoires sont prévisible dès maintenant, quelque chose que vous ne voulez pas pour les Id de session et la comme.

Comment casser un Générateur Linéaire à Congruence

L'hypothèse qu'un attaquant pourrait avoir à attendre pour le LCG à répéter après un cycle complet est mauvais. Même avec une optimale du cycle (le module m dans sa relation de récurrence), il est très facile de prédire les valeurs futures en beaucoup moins de temps qu'un cycle complet. Après tout, c'est juste un tas d'équations modulaires qui doivent être résolus, ce qui devient facile dès que vous avez observé assez les valeurs de sortie de la GRILLE.

La sécurité ne s'améliore pas avec un "meilleur" de la graine. Il n'a tout simplement pas d'importance si vous les graines avec une valeur aléatoire générée par SecureRandom ou même produire de la valeur par laminage d'une mourir plusieurs fois.

Un attaquant simplement calculer la graine à partir de la sortie des valeurs observées. Cela prend nettement moins de temps que 2^48 dans le cas de java.util.Random. Les mécréants peuvent essayer ce expérience, où il est montré que vous pouvez prédire l'avenir de l' Random sorties d'observation de deux(!) les valeurs de sortie dans le temps d'environ 2^16. Il prend même pas une seconde sur un ordinateur moderne pour prédire la sortie de votre nombres aléatoires droit maintenant.

Conclusion

Remplacer votre code actuel. Utilisation SecureRandom exclusivement. Au moins vous aurez un peu de garantir que le résultat sera difficile à prédire. Si vous voulez les propriétés d'un point de vue cryptographique sécurisé PRNG (dans votre cas, c'est ce que vous voulez), alors vous devez aller avec SecureRandom seulement. Faire le malin sur la modification de la façon dont il était censé être utilisé entraîneront presque toujours quelque chose de moins sûr...

Si vous exécutez deux fois java.util.Random.nextLong() avec la même graine, il va produire le même nombre. Pour des raisons de sécurité, vous voulez coller avec java.security.SecureRandom parce qu'il est beaucoup moins prévisible.

Les 2 Classes sont similaires, je pense que vous avez juste besoin de changer Random à SecureRandom avec un outil de refactoring et de la plupart de votre code fonctionne.

La référence actuelle de la mise en œuvre de java.util.Random.nextLong() fait deux appels à la méthode next(int) qui directement expose 32 bits de la graine:

protected int next(int bits) {
    long nextseed;
    //calculate next seed: ...
    //and store it in the private "seed" field.
    return (int)(nextseed >>> (48 - bits));
}

public long nextLong() {
    //it's okay that the bottom word remains signed.
    return ((long)(next(32)) << 32) + next(32);
}

La partie supérieure de 32 bits de la suite de nextLong() sont les bits de la graine à l'époque. Étant donné que la largeur de la graine est de 48 bits (dit la javadoc), il suffit* pour itérer sur les autres 16 bits (c'est seulement 65.536 tente) pour déterminer la graine qui a produit le deuxième 32 bits.

Une fois que la graine est connu, tous les symboles suivants peuvent être facilement calculés.

L'aide de la sortie de nextLong() directement, en partie le secret de la PNG à un degré que tout le secret peut être calculée avec très peu d'efford. Dangereux!

* Il y a des efforts nécessaires si les 32 bits sont négatives, mais on peut le trouver.

Je vais essayer d'utiliser des mots de base, de sorte que vous pouvez facilement comprendre la différence entre le Hasard et secureRandom et de l'importance de SecureRandom Classe.

Jamais demandé comment OTP(one time password) est généré?
Pour générer un OTP nous aussi utiliser Aléatoire et SecureRandom classe. Maintenant, pour faire de votre OTP forte, SecureRandom est mieux car il a fallu 2^128 essayer, pour faire craquer le bureau du procureur qui est presque impossible par l'actuelle machine, mais si utilisé Aléatoire de Classe alors votre OTP peut être forcé par quelqu'un qui peut nuire à vos données, car il a fallu seulement 2^48 essayer, à se fissurer.