Verwenden Sie den privaten RSA-Schlüssel, um einen öffentlichen Schlüssel zu generieren?

Ich verstehe das nicht wirklich:

Laut: http://www.madboa.com/geek/openssl/#key-rsa können Sie einen öffentlichen Schlüssel aus einem privaten Schlüssel generieren.

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

Mein erster Gedanke war, dass sie zusammen zu zweit erzeugt werden. Enthält der private RSA-Schlüssel die Summe? oder der öffentliche Schlüssel?

openssl genrsa -out mykey.pem 1024

wird tatsächlich ein öffentlich-privates Schlüsselpaar erzeugen. Das Paar wird in der generierten mykey.pemDatei gespeichert.

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

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

BEARBEITEN: Überprüfen Sie den Beispielabschnitt hier . So geben Sie einfach den öffentlichen Teil eines privaten Schlüssels aus:

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

Verwenden Sie ssh-keygen, um einen für SSH-Zwecke verwendbaren öffentlichen Schlüssel zu erhalten :

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

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

Wenn Sie den öffentlichen Schlüssel für die Verwendung mit OpenSSH extrahieren möchten, müssen Sie den öffentlichen Schlüssel etwas anders abrufen

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

Dieses öffentliche Schlüsselformat ist mit OpenSSH kompatibel. Fügen Sie den öffentlichen Schlüssel an remote:~/.ssh/authorized_keysund Sie können loslegen

Dokumente von SSH-KEYGEN(1)

ssh-keygen -y [-f input_keyfile]  

-y Diese Option liest eine private Datei im OpenSSH-Format und druckt einen öffentlichen OpenSSH-Schlüssel an stdout.

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

A.1.2 Syntax des privaten RSA-Schlüssels

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

  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, enthält dieses Format eine Reihe von Feldern, einschließlich des Moduls und des öffentlichen Exponenten, und ist daher eine strikte Obermenge der Informationen in einem öffentlichen RSA-Schlüssel .

Meine Antwort unten ist etwas lang, aber hoffentlich enthält sie einige Details, die in früheren Antworten fehlen. Ich werde mit einigen verwandten Aussagen beginnen und schließlich die erste Frage beantworten.

Um etwas mit dem RSA-Algorithmus zu verschlüsseln, benötigen Sie ein Exponentenpaar aus Modul und Verschlüsselung (öffentlich) (n, e). Das ist dein öffentlicher Schlüssel. Um etwas mit dem RSA-Algorithmus zu entschlüsseln, benötigen Sie ein Exponentenpaar aus Modul und Entschlüsselung (privat) (n, d). Das ist dein privater Schlüssel.

Um etwas mit dem öffentlichen RSA-Schlüssel zu verschlüsseln, behandeln Sie Ihren Klartext als Zahl und erhöhen ihn auf die Potenz des Moduls 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 des Moduls d:

plaintext = ( ciphertext^d ) mod n

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

openssl genrsa -out private.pem 1024

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

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

Führen Sie die folgenden Schritte aus, um den Inhalt des privaten RSA-Schlüssels private.pem zu zerlegen, der mit dem obigen Befehl openssl generiert wurde (Ausgabe hier auf Beschriftungen abgeschnitten):

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 (n, d) Paaren bestehen? Warum gibt es 6 zusätzliche Komponenten? Es enthält e (öffentlicher Exponent), sodass der öffentliche RSA-Schlüssel aus dem privaten RSA-Schlüssel private.pem generiert / extrahiert / abgeleitet werden kann. Die restlichen 5 Komponenten beschleunigen den Entschlüsselungsprozess. Es stellt sich heraus, dass durch Vorberechnung und Speicherung dieser 5 Werte die RSA-Entschlüsselung um den Faktor 4 beschleunigt werden kann. Die Entschlüsselung funktioniert ohne diese 5 Komponenten, kann jedoch schneller durchgeführt werden, wenn Sie sie zur Hand haben. Der Beschleunigungsalgorithmus basiert auf dem chinesischen Restsatz .

Ja, der private RSA-Schlüssel private.pem enthält tatsächlich alle diese 8 Werte. Keiner von ihnen wird im laufenden Betrieb generiert, wenn Sie den vorherigen Befehl ausführen. Führen Sie die folgenden Befehle aus 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 PKCS # 1 v1.5 als alternative ( zweite ) Darstellung empfohlen . Der PKCS # 1 v2.0- Standard schließt e- und d-Exponenten insgesamt von der alternativen Darstellung aus. PKCS # 1 v2.1 und v2.2 schlagen weitere Änderungen an der alternativen Darstellung vor, indem optional mehr CRT-bezogene Komponenten einbezogen werden.

Führen Sie die folgenden Schritte aus, um den Inhalt des öffentlichen RSA-Schlüssels public.pem anzuzeigen (Ausgabe hier auf Beschriftungen gekürzt):

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

Modulus             - n
Exponent (public)   - e

Keine Überraschungen hier. Es ist nur (n, e) Paar, wie versprochen.

Beantworten Sie nun endlich die erste Frage: Wie oben gezeigt, enthält der mit openssl generierte private RSA-Schlüssel Komponenten sowohl öffentlicher als auch privater Schlüssel und einige weitere. Wenn Sie einen öffentlichen Schlüssel aus dem privaten Schlüssel generieren / extrahieren / ableiten, kopiert openssl zwei dieser Komponenten (e, n) in eine separate Datei, die zu Ihrem öffentlichen Schlüssel wird.

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

openssl rsa -text -in mykey.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
}

So gibt es genügend Daten den öffentlichen Schlüssel (Modul und öffentliche Exponenten) zu berechnen, das ist , was openssl rsa -in mykey.pem -pubouttut

Hier in diesem Code erstellen wir zuerst einen privaten RSA-Schlüssel, der jedoch auch ein Paar seines öffentlichen Schlüssels enthält. Um Ihren tatsächlichen öffentlichen Schlüssel zu erhalten, tun wir dies einfach

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

hoffen , dass Sie es für weitere Informationen erhalten Check dieses

Zunächst eine kurze Zusammenfassung der RSA-Schlüsselgenerierung.

1. Wählen Sie zufällig zwei zufällige wahrscheinliche Primzahlen der entsprechenden Größe (p und q).
2. Multiplizieren Sie die beiden Primzahlen miteinander, um den Modul (n) zu erhalten.
3. Wählen Sie einen öffentlichen Exponenten (e).
4. Rechnen Sie mit den Primzahlen und dem öffentlichen Exponenten, um den privaten Exponenten (d) zu erzeugen.

Der öffentliche Schlüssel besteht aus dem Modul und dem öffentlichen Exponenten.

Ein minimaler privater Schlüssel würde aus dem Modul und dem privaten Exponenten bestehen. Es gibt keinen rechnerisch realisierbaren todsicheren Weg, um von einem bekannten Modul und privaten Exponenten zum entsprechenden öffentlichen Exponenten zu gelangen.

Jedoch:

1. Praktische private Schlüsselformate speichern fast immer mehr als n und d.
2. Wenn e normalerweise nicht zufällig ausgewählt wird, wird einer von wenigen bekannten Werten verwendet. Wenn e einer der bekannten Werte ist und Sie d kennen, ist es einfach, e durch Ausprobieren herauszufinden.

In den meisten praktischen RSA-Implementierungen können Sie den öffentlichen Schlüssel vom privaten Schlüssel abrufen. Es wäre möglich, ein RSA-basiertes Kryptosystem aufzubauen, in dem dies nicht möglich war, aber es ist nicht das Richtige.

Use the following commands:

1. openssl req -x509 -nodes -days 365 -sha256 -newkey rsa:2048 -keyout mycert.pem -out mycert.pem

Loading 'screen' into random state - done
Generating a 2048 bit RSA private key
.............+++
..................................................................................................................................................................+++
writing new private key to 'mycert.pem'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.

2. If you check there will be a file created by the name : mycert.pem

3. openssl rsa -in mycert.pem -pubout > mykey.txt
writing RSA key

4. If you check the same file location a new public key : mykey.txt will be created.