RSA 2048 Schlüsselpaargenerierung: über openssl 0,5s über gpg 30s, warum der Unterschied?

RSA 2048-Schlüsselpaargenerierung: über openssl 0,5s über gpg 30s, warum der Unterschied Es gibt mehrere Programme, die öffentliche / private RSA-Schlüsselpaare erzeugen können

GnuPG / OpenPGP hat zum Beispiel einen Zauberer, über den aufgerufen wird

gpg --gen-key

OpenSSL kann über diese Befehlszeilen ein Schlüsselpaar generieren

openssl genrsa -out testkey.private 2048
openssl rsa -in testkey.private -pubout -out testkey.public

für das gleiche, das ein Schlüsselpaar RSA 2048-Bit erzeugt, kann ich - auf derselben Maschine - sehr unterschiedliche Zeiten wahrnehmen.

opensslDas Generieren eines Schlüsselpaars in ungefähr 0,5 Sekunden
gpgdauert ungefähr 30 Sekunden und sogar Werbung "Maus bewegen, um Zufälligkeit / Entropie zu erzeugen"

Kann der Unterschied erklärt werden? Ich weiß, dass gpg ein bisschen mehr tut als nur die RSA-Schlüsselerstellung, aber ich wähle speziell Option (4)

Bitte wählen Sie die gewünschte Art von Schlüssel aus:
   (1) RSA und RSA (Standard)
   (2) DSA und Elgamal
   (3) DSA (nur Zeichen)
   (4) RSA (nur Zeichen)
Deine Auswahl?

Daher wird wirklich nur ein 2048-Bit-RSA-Schlüsselpaar generiert. Doch der Zeitunterschied beträgt 30 Sekunden?

Mir scheint, dass entweder gpg unnötig Zeit verschwendet oder OpenSSL nicht genug Zeit wartet und daher unsichere Schlüssel erstellt.

Meine Frage ist, was könnte den Unterschied erklären?

Aktualisieren

Die RSA-Erstellung muss eine gewisse Zufälligkeit als Eingabe verwenden. Um sicherzustellen, dass das schnelle Öffnen nicht einfach das Ergebnis einer gespeicherten Zufälligkeit ist, starte ich es mehrmals

time bash -c "für i in {1..50}; do openssl genrsa -out / dev / null 2048; done;"

was ergibt

echte 0m16.577s
Benutzer 0m16.309s
sys 0m0.092s

Das heißt, dass für 50 2048-Bit-RSA-Schlüssel (ich nehme an, dass sie viel Entropie / Zufälligkeit benötigen) openssl immer noch nur 16 Sekunden benötigt. Meine Annahme hier wäre daher die "Antwort", dass openssl gebrochen werden muss. Immerhin bin ich misstrauisch, dass mein Linux (ein 3.2.0-59-Kernel) so groß geworden ist, Zufälligkeit zu erzeugen.

Vielleicht liegt der Unterschied einfach darin, dass openssl /dev/urandomund gpg verwendet werden. /dev/randomWenn true, könnte dies den Zeitunterschied erklären. Mein Problem ist, dass ich nicht weiß, wie ich davon erfahren würde, um dies zu überprüfen.

update2

Um die Quelle von openssls Zufall zu testen, habe ich verwendet

strace -xe trace = Datei, lesen, schreiben, schließen openssl genrsa -out testkey5.private 2048 2> & 1 | grep random -A1

was ergibt

open ("/ dev / urandom", O_RDONLY | O_NOCTTY | O_NONBLOCK) = 4
Lesen Sie (4, "\ x21 \ xd8 \ xaa \ xf1 \ x2b \ x5f \ x4a \ x89 \ x5d \ x6c \ x58 \ x82 \ xc1 \ x88 \ x21 \ x04 \ xfa \ x5b \ x18 \ x98 \ x8a \ x34 \ x2b \ xe3 \ xf3 \ xc0 \ xb1 \ xef \ xfb \ x44 \ x15 \ x09 ", 32) = 32

es scheint also, dass 32 Bytes von /dev/urandom(nicht das "bessere" /dev/random) für das 2048-Bit-RSA-Schlüsselpaar in openssl ausreichen. Deshalb ist es so schnell!

Messungen

2048-Bit-RSA-Schlüsselpaar-Generierungsmittel

• Nur 32 Bytes /dev/urandom(mit openssl)
• 300 Bytes /dev/random(mit openPGP GNU Privacy Guard)

das erklärt natürlich den zeitunterschied!

GnuPG verbraucht mehrere Bytes /dev/randomfür jedes zufällige Byte, das es tatsächlich verwendet. Sie können dies einfach mit diesem Befehl überprüfen:

start cmd:> strace -e trace=open,read gpg --armor --gen-random 2 16 2>&1 | tail
open("/etc/gcrypt/rngseed", O_RDONLY)   = -1 ENOENT (No such file or directory)
open("/dev/urandom", O_RDONLY)          = 3
read(3, "\\\224F\33p\314j\235\7\200F9\306V\3108", 16) = 16
open("/dev/random", O_RDONLY)           = 4
read(4, "/\311\342\377...265\213I"..., 300) = 128
read(4, "\325\3\2161+1...302@\202"..., 172) = 128
read(4, "\5[\372l\16?\...6iY\363z"..., 44) = 44
open("/home/hl/.gnupg/random_seed", O_WRONLY|O_CREAT, 0600) = 5
cCVg2XuvdjzYiV0RE1uzGQ==
+++ exited with 0 +++

Um 16 Bytes hochwertiger Entropie auszugeben, liest GnuPG 300 Bytes aus /dev/random.

Dies wird hier erklärt: Zufallszahlen-Subsystemarchitektur

Linux speichert maximal 4096 Byte (siehe cat /proc/sys/kernel/random/poolsize) Entropie. Wenn ein Prozess mehr als verfügbar benötigt (siehe cat /proc/sys/kernel/random/entropy_avail), wird die CPU-Auslastung mehr oder weniger irrelevant, da die Einspeisungsgeschwindigkeit des Entropiepools des Kernels zum relevanten Faktor wird.

Ihr Vorschlag , dass dieser Unterschied ist , weil opensslAnwendungen / dev / urandom und gpgAnwendungen /dev/randomkorrekt ist .

Sie können beobachten, wie die verfügbare Entropie beim Generieren von Schlüsseln abnimmt, indem Sie Folgendes gpgverwenden:

watch -n 1 cat /proc/sys/kernel/random/entropy_avail

Ich habe ein Programm zum Generieren der Beschreibung der Schritte zum Einrichten einer OpenGPG-Smartcard verwendetgpg , sodass ich gpgmehrere Male ausführen musste, bis alles wie beabsichtigt funktioniert hat. Nach den ersten Läufen bemerkte ich, dass /dev/randomes nicht genug Entropie geben würde und gpg einfach warten würde, bis sich neue Entropie ansammelt.

Ich habe ein kleines Programm geschrieben, um zusätzliche nicht zufällige Daten bereitzustellen, und wenn ich dies tue, gpgwürde ich nicht "anhalten", sondern die Schlüssel fast sofort generieren: schön, um das Skript zu testen, damit es korrekt ausgeführt wird, aber natürlich nicht etwas, das Sie tun sollten, während Sie Ihre realen Daten generieren Schlüssel.

Das Programm zum Beschleunigen gpg( nicht in realen Situationen verwenden ):

# For testing purposes only 
# DO NOT USE THIS, tHIS DOES NOT PROVIDE ENTROPY TO /dev/random

import fcntl
import time
import struct

RNDADDENTROPY=0x40085203

while True:
    random = "3420348024823049823-984230942049832423l4j2l42j"
    t = struct.pack("ii32s", 8, 32, random)
    with open("/dev/random", mode='wb') as fp:
        # as fp has a method fileno(), you can pass it to ioctl
        res = fcntl.ioctl(fp, RNDADDENTROPY, t)
        time.sleep(0.001)

Wenn ich dies beim Anschauen ausführe, entropy_availkann ich sehen, dass die verfügbare Entropie auf über 3800 ansteigt.