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

9

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!

Menschlichkeit UND Frieden
quelle

Antworten:

10

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.

Hauke ​​Laging
quelle
Beeindruckend. Vielen Dank für den Einblick. Ich denke, es ist ziemlich aufschlussreich in Bezug auf die Frage! Während openssl mit 32 Bytes weniger Qualität zufrieden ist /dev/urandom, sagt gpg sogar "1 Byte /dev/randomist nicht gut genug für 1 Byte Zufall". Würde dies nicht bedeuten, dass openssl-Schlüssel im Vergleich zu gpg's anfälliger für "zu wenig Zufälligkeit" sind?
Menschlichkeit und
1
@humanityANDpeace Zufälligkeit ist eine endlose Diskussion. Vor nicht allzu langer Zeit hat der "Hauptbenutzer" dieser Site die Behauptung aufgestellt, die /dev/urandomfür Kryptozwecke gut genug sei. Auf der GnuPG-Mailingliste würde er wahrscheinlich dafür ausgelacht werden. AFAIK Es ist unmöglich zu beweisen, dass bestimmte Daten rein zufällig sind. Sie können Nicht-Zufälligkeit finden, aber nur dort, wo Sie genau nach diesem Muster suchen.
Hauke ​​Laging
Ja, ich verstehe :) Die Tatsache, dass GPG 300 Byte verwendet, /dev/randomwährend OpenSSL nur 32 Byte verwendet, /dev/urandomscheint ein potenzielles Sicherheitsrisiko für den vorsichtigen Benutzer zu sein, der ein 2048-Bit-RSA-Schlüsselpaar möchte. Ich würde mich daher für gpg entscheiden. 32bytes scheint schrecklich wenig
Menschlichkeit
2
@HaukeLaging Der "Hauptbenutzer" dieser Site erhielt diesen Rat vom "Hauptbenutzer" für Informationssicherheit und Kryptographie mit einer Erklärung, die sinnvoll ist (im Gegensatz zur Linux-Berechnung der Entropiepoolgröße, die dies nicht tut). Ist ein Rand von / dev / urandom für einen Anmeldeschlüssel sicher? „Die kurze Antwort lautet ja. Die lange Antwort lautet auch ja. “
Gilles 'SO - hör auf böse zu sein'
2
32 Bytes, die von einem gut gesetzten CSPRNG gelesen werden, bieten 256 Bit Sicherheit (was verdammt viel ist ). Ein RSA-2048-Bit-Schlüssel bietet nur etwa 112 Bit Sicherheit. Die einzige zweifelhafte Eigenschaft von a /dev/urandomist, dass es (unter Linux) nicht blockiert, bevor es direkt nach dem Booten gesetzt wird. Sobald es ausgesät wurde, bleibt es für immer sicher.
CodesInChaos
7

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.

Anthon
quelle
Danke für die Antwort. Ich freue mich immer noch darauf, gpg zu testen, das leider weniger stapelbar und interaktiver ist. .. Immer noch. Sind Sie sicher, dass der Wiederholungsaufruf catvon selbst die Entropie nicht bereits erschöpft ? Haben Sie Beweise oder Quellen, aus denen hervorgeht, dass GPG-Anwendungen /dev/randomdie Antwort perfektionieren würden? Bedeutet das schließlich auch, dass openssl RSA-Schlüsselpaare von geringerer Qualität erzeugt als gqg?
Menschlichkeit und
@humanityANDpeace Es ist möglich (wenn auch weniger offensichtlich), GnuPG im Batch-Modus zu verwenden. Suchen Sie Unattended key generationin der Datei /usr/share/doc/packages/gpg2/DETAILS(oder was auch immer es in Ihrer Distribution sein mag). Der /dev/randomBeweis ist in meiner Antwort.
Hauke ​​Laging
@humanityANDpeace Haukes Antwort ist eher zutreffend, aber ich habe mehrere Hinweise darauf gefunden, als ich nachgeforscht habe, wie ich meine OpenGPG-Karte einrichten kann. Batching ist nicht trivial, aber das Python-Programm, das ich verwendet habe, habe ich auf bitbucket
Anthon
Ich mag beide Antworten und beide schlagen die richtige Lösung vor. danke für den link bitbucket!
Menschlichkeit und
1
Das Laichen eines neuen Prozesses verbraucht Entropie, daher wäre ein besserer Ansatz die Verwendung der readeingebauten Shell:while read -r < /proc/sys/kernel/random/entropy_avail; do clear; date; printf '\nAvailable entropy: %s bytes\n' "$REPLY"; sleep 1; done
Nyuszika7h