Privater RSA-Schlüssel zum Erzeugen des öffentlichen Schlüssels verwenden?

Question

Das verstehe ich nicht wirklich:

Nach Angaben von https://www.madboa.com/geek/openssl/#key-rsa können Sie einen öffentlichen Schlüssel aus einem privaten Schlüssel erzeugen.

openssl genrsa -out mykey.pem 1024
openssl rsa -in mykey.pem -pubout > mykey.pub

Ursprünglich dachte ich, dass sie zusammen in einem Paar erzeugt werden.

Enthält der private RSA-Schlüssel die Summe? Oder den öffentlichen Schlüssel?

Answer 1

openssl genrsa -out mykey.pem 1024

tatsächlich ein Paar aus öffentlichem und privatem Schlüssel erzeugen wird. Das Paar wird in dem erzeugten mykey.pem Datei.

openssl rsa -in mykey.pem -pubout > mykey.pub

extrahiert den öffentlichen Schlüssel und gibt ihn aus. Hier ist ein Link zu einer Seite, die dies besser beschreibt.

EDIT: Prüfen Sie den Abschnitt mit den Beispielen aquí . Um nur den öffentlichen Teil eines privaten Schlüssels auszugeben:

openssl rsa -in key.pem -pubout -out pubkey.pem

Um einen brauchbaren öffentlichen Schlüssel für SSH-Zwecke zu erhalten, verwenden Sie ssh-keygen :

ssh-keygen -y -f key.pem > key.pub

Answer 2

Leute, die nach einem öffentlichen SSH-Schlüssel suchen...

Wenn Sie den öffentlichen Schlüssel für die Verwendung mit OpenSSH extrahieren wollen, müssen Sie den öffentlichen Schlüssel auf eine etwas andere Weise erhalten

$ ssh-keygen -y -f mykey.pem > mykey.pub

Dieses Format für öffentliche Schlüssel ist mit OpenSSH kompatibel. Hängen Sie den öffentlichen Schlüssel an remote:~/.ssh/authorized_keys und Sie sind startklar

---

Dokumente von SSH-KEYGEN(1)

ssh-keygen -y [-f input_keyfile]  

-y Diese Option liest eine Datei im privaten OpenSSH-Format und gibt einen öffentlichen OpenSSH-Schlüssel auf stdout aus.

Answer 3

In den meisten Programmen, die private RSA-Schlüssel erzeugen, einschließlich OpenSSL, wird der private Schlüssel als PKCS#1 RSAPrivatekey Objekt oder eine Variante davon:

A.1.2 Syntax des privaten RSA-Schlüssels

Ein privater RSA-Schlüssel sollte mit dem ASN.1-Typ dargestellt werden
RSAPrivateKey:

  RSAPrivateKey ::= SEQUENCE {
      version           Version,
      modulus           INTEGER,  -- n
      publicExponent    INTEGER,  -- e
      privateExponent   INTEGER,  -- d
      prime1            INTEGER,  -- p
      prime2            INTEGER,  -- q
      exponent1         INTEGER,  -- d mod (p-1)
      exponent2         INTEGER,  -- d mod (q-1)
      coefficient       INTEGER,  -- (inverse of q) mod p
      otherPrimeInfos   OtherPrimeInfos OPTIONAL
  }

Wie Sie sehen können, hat dieses Format eine Reihe von Feldern, einschließlich des Modulus und des öffentlichen Exponenten, und ist somit eine strenge Obermenge der Informationen in einer Öffentlicher RSA-Schlüssel .

Answer 4

Meine nachstehende Antwort ist etwas langatmig, aber ich hoffe, sie enthält einige Details, die in früheren Antworten fehlen. Ich beginne mit einigen zusammenhängenden Aussagen und beantworte schließlich die Ausgangsfrage.

Um etwas mit dem RSA-Algorithmus zu verschlüsseln, benötigen Sie ein Modulus- und ein (öffentliches) Exponentenpaar (n, e) zur Verschlüsselung. Das ist Ihr öffentlicher Schlüssel. Um etwas mit dem RSA-Algorithmus zu entschlüsseln, benötigen Sie den Modulus und das (private) Exponentenpaar (n, d) für die Entschlüsselung. Das ist Ihr privater Schlüssel.

Um etwas mit dem öffentlichen RSA-Schlüssel zu verschlüsseln, behandeln Sie Ihren Klartext als eine Zahl und erhöhen ihn in die Potenz von e Modulus n:

ciphertext = ( plaintext^e ) mod n

Um etwas mit dem privaten RSA-Schlüssel zu entschlüsseln, behandeln Sie Ihren Chiffretext als Zahl und erhöhen ihn auf die Potenz von d Modulus n:

plaintext = ( ciphertext^d ) mod n

Um einen privaten (d,n)-Schlüssel mit openssl zu erzeugen, können Sie den folgenden Befehl verwenden:

openssl genrsa -out private.pem 1024

Um den öffentlichen (e,n) Schlüssel aus dem privaten Schlüssel mit openssl zu erzeugen, können Sie folgenden Befehl verwenden:

openssl rsa -in private.pem -out public.pem -pubout

Um den Inhalt des privaten RSA-Schlüssels private.pem, der mit dem obigen Befehl openssl erzeugt wurde, zu analysieren, führen Sie Folgendes aus (die Ausgabe wurde hier auf Etiketten gekürzt):

openssl rsa -in private.pem -text -noout | less

modulus         - n
privateExponent - d
publicExponent  - e
prime1          - p
prime2          - q
exponent1       - d mod (p-1)
exponent2       - d mod (q-1)
coefficient     - (q^-1) mod p

Sollte der private Schlüssel nicht nur aus dem Paar (n, d) bestehen? Warum gibt es 6 zusätzliche Komponenten? Er enthält e (öffentlicher Exponent), damit der öffentliche RSA-Schlüssel aus dem privaten RSA-Schlüssel private.pem erzeugt/extrahiert/abgeleitet werden kann. Die restlichen 5 Komponenten sind dazu da, den Entschlüsselungsprozess zu beschleunigen. Es hat sich herausgestellt, dass durch die Vorberechnung und Speicherung dieser 5 Werte die RSA-Entschlüsselung um den Faktor 4 beschleunigt werden kann. Die Entschlüsselung funktioniert auch ohne diese 5 Komponenten, aber sie kann schneller durchgeführt werden, wenn man sie zur Hand hat. Der Beschleunigungsalgorithmus basiert auf dem Chinese Remainder Theorem .

Ja, private.pem, der private RSA-Schlüssel, enthält tatsächlich alle diese 8 Werte; keiner von ihnen wird beim Ausführen des vorherigen Befehls spontan erzeugt. Versuchen Sie, die folgenden Befehle auszuführen und vergleichen Sie die Ausgabe:

# Convert the key from PEM to DER (binary) format
openssl rsa -in private.pem -outform der -out private.der

# Print private.der private key contents as binary stream
xxd -p private.der

# Now compare the output of the above command with output 
# of the earlier openssl command that outputs private key
# components. If you stare at both outputs long enough
# you should be able to confirm that all components are
# indeed lurking somewhere in the binary stream
openssl rsa -in private.pem -text -noout | less

Diese Struktur des privaten RSA-Schlüssels wird von der PKCS#1 v1.5 als Alternative ( zweite ) Darstellung. PKCS#1 v2.0 Standard schließt die Exponenten e und d von der alternativen Darstellung völlig aus. PKCS#1 v2.1 y v2.2 weitere Änderungen an der alternativen Darstellung vorschlagen, indem sie optional weitere CRT-bezogene Komponenten einbeziehen.

Um den Inhalt des öffentlichen RSA-Schlüssels public.pem zu sehen, führen Sie den folgenden Befehl aus (die Ausgabe wurde hier auf Etiketten gekürzt):

openssl rsa -in public.pem -text -pubin -noout

Modulus             - n
Exponent (public)   - e

Hier gibt es keine Überraschungen. Es ist einfach ein (n, e)-Paar, wie versprochen.

Nun endlich zur Beantwortung der Ausgangsfrage: Wie oben gezeigt wurde, enthält ein privater RSA-Schlüssel, der mit openssl erzeugt wurde, Komponenten sowohl des öffentlichen als auch des privaten Schlüssels und einige mehr. Wenn Sie den öffentlichen Schlüssel aus dem privaten Schlüssel erzeugen/extrahieren/ableiten, kopiert openssl zwei dieser Komponenten (e,n) in eine separate Datei, die Ihr öffentlicher Schlüssel wird.

Answer 5

Der öffentliche Schlüssel ist nicht in der PEM-Datei gespeichert, wie manche Leute glauben. Die folgende DER-Struktur ist in der privaten Schlüsseldatei vorhanden:

openssl rsa -text -in meinSchlüssel.pem

RSAPrivateKey ::= SEQUENCE {
  version           Version,
  modulus           INTEGER,  -- n
  publicExponent    INTEGER,  -- e
  privateExponent   INTEGER,  -- d
  prime1            INTEGER,  -- p
  prime2            INTEGER,  -- q
  exponent1         INTEGER,  -- d mod (p-1)
  exponent2         INTEGER,  -- d mod (q-1)
  coefficient       INTEGER,  -- (inverse of q) mod p
  otherPrimeInfos   OtherPrimeInfos OPTIONAL
}

Es sind also genügend Daten vorhanden, um den öffentlichen Schlüssel (Modulus und öffentlicher Exponent) zu berechnen, und das ist es, was openssl rsa -in mykey.pem -pubout tut