Bonjour,
je suppose que vous avez lu:
http://eprint.iacr.org/2012/064 , ou
<
https://freedom-to-tinker.com/blog/nadiah/new-research-theres-no-need-panic-over-factorable-keys-just-mind-your-ps-and-qs >
Je ne suis pas sûr de bien comprendre le problème.
J'ai appris que la solidité de RSA repose sur le fait qu'il est très
difficile de factoriser un très grand nombre composé de deux très
grands nombres premiers. Bien.
Les auteurs du papier ci dessus ont téléchargés un très grand nombre
de clés publiques RSA et ont effectués des PGCD entre chacune des
paires possibles. Si on trouve un PGCD différent de 1, alors cela
signifie que les deux nombres ont un facteur en commun, et de fait, on
retrouve les diviseurs de chacune des deux clés.
Si la clé A = Pxa et B = Pxb alors le PGCD vaut P, et avec deux divisions
on retrouve a et b, puis découle les clés privées de A et B.
RSA serait donc "affaibli" dans certains cas lorsque des clés partagent
des facteurs communs.
Quelque chose m'échappe, c'est la manière de calculet un PGCD entre A
et B. Pourquoi ce moyen serait il plus rapide que de calculer les
facteurs premiers de A et B?
La seconde chose qui m'étonne concerne l'explication de la faiblesse. Il
est indiqué qu'un mauvais générateur aléatoire créerait ses clés comme
cela:
prng.seed(seed)
p = prng.generate_random_prime()
q = prng.generate_random_prime()
N = p*q
Avec l'explication suivante:
Si le (seed) est mauvais, alors on peut connaître N et tous les
équipements utilisant cette méthode auraient le même 'N'.
Certes, mais faut il encore que le seed soit mauvais partout, et de la
même manière sur tous les équipements employant la méthode.
La seconde méthode, utilisée pour augmenter la sécurité est la
suivante:
prng.seed(seed)
p = prng.generate_random_prime()
prng.add_randomness(bits)
q = prng.generate_random_prime()
N = p*q
Avec l'explication:
Si le seed est mauvais, alors p est identique entre tous les équipements
employant cet algo, et q change. Si on a plusieurs clés d'un équipement,
on calcule le PGCD de ces clés et on retrouve chacun des 'p' et 'q'.
Encore une fois, il faut que le seed soit tout le temps mauvais de la
même manière. L'article continue en indiquant:
"OpenSSL's RSA key generation functions this way: each time random bits
are produced from the entropy pool to generate the primes p and q, the
current time in seconds is added to the entropy pool. Many, but not all,
of the vulnerable keys were generated by OpenSSL and OpenSSH, which
calls OpenSSL's RSA key generation code."
On parle donc bien de la seconde manière dont est générée le 'q'
puisque add_randomness(seconds) est utilisé, mais d'où viendrait
le faible prng.seed(seed) faible?
De manière très pragmatique, ça m'ennuie. Car j'ai diffusé ma clé
publique ssh en différents endroits, et la clé publique de mon
serveur est accessible. Cela signifie qu'au moins plusieurs
personnes en ont deux, et peuvent donc faire le PGCD afin de
retrouver mes clés privées?
Merci pour toute remarque, précisions sur ce sujet.
--
Kevin