Utiliser la clé privée RSA pour générer une clé publique?

Je ne comprends pas vraiment celui-ci:

selon: http://www.madboa.com/geek/openssl/#key-rsa , vous pouvez générer une clé publique à partir d'une clé privée.

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

Ma pensée initiale était qu'ils sont générés par paire ensemble. La clé privée RSA contient-elle la somme? ou la clé publique?

openssl genrsa -out mykey.pem 1024

produira en fait une paire de clés publique-privée. La paire est stockée dans le mykey.pemfichier généré .

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

va extraire la clé publique et l'imprimer. Voici un lien vers une page qui décrit mieux cela.

EDIT: Consultez la section des exemples ici . Pour simplement sortir la partie publique d'une clé privée:

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

Pour obtenir une clé publique utilisable à des fins SSH, utilisez ssh-keygen :

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

Les personnes recherchant une clé publique SSH ...

Si vous cherchez à extraire la clé publique pour l'utiliser avec OpenSSH, vous devrez obtenir la clé publique un peu différemment

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

Ce format de clé publique est compatible avec OpenSSH. Ajoutez la clé publique à remote:~/.ssh/authorized_keyset vous serez prêt à partir

documents de SSH-KEYGEN(1)

ssh-keygen -y [-f input_keyfile]  

-y Cette option lira un fichier privé au format OpenSSH et imprimera une clé publique OpenSSH sur stdout.

Dans la plupart des logiciels qui génèrent des clés privées RSA, y compris openssl, la clé privée est représentée comme un objet PKCS # 1 RSAPrivatekey ou une variante de celui-ci:

A.1.2 Syntaxe de clé privée RSA

Une clé privée RSA doit être représentée avec le type ASN.1
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
  }

Comme vous pouvez le voir, ce format a un certain nombre de champs, y compris le module et l'exposant public et est donc un sur-ensemble strict des informations dans une clé publique RSA .

Ma réponse ci-dessous est un peu longue, mais j'espère qu'elle fournit certains détails qui manquent dans les réponses précédentes. Je vais commencer par quelques déclarations connexes et enfin répondre à la question initiale.

Pour crypter quelque chose à l'aide de l'algorithme RSA, vous avez besoin d'un module et d'une paire d'exposants de cryptage (public) (n, e). Voilà votre clé publique. Pour décrypter quelque chose à l'aide de l'algorithme RSA, vous avez besoin d'un module et d'une paire d'exposants de décryptage (privés) (n, d). Voilà votre clé privée.

Pour crypter quelque chose à l'aide de la clé publique RSA, vous traitez votre texte en clair comme un nombre et vous l'élevez à la puissance du module e n:

ciphertext = ( plaintext^e ) mod n

Pour décrypter quelque chose à l'aide de la clé privée RSA, vous traitez votre texte chiffré comme un nombre et l'élevez à la puissance du module d n:

plaintext = ( ciphertext^d ) mod n

Pour générer une clé privée (d, n) en utilisant openssl, vous pouvez utiliser la commande suivante:

openssl genrsa -out private.pem 1024

Pour générer une clé publique (e, n) à partir de la clé privée en utilisant openssl, vous pouvez utiliser la commande suivante:

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

Pour disséquer le contenu de la clé RSA privée private.pem générée par la commande openssl ci-dessus, exécutez la commande suivante (sortie tronquée aux étiquettes ici):

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

La clé privée ne doit-elle pas consister en une paire (n, d) uniquement? Pourquoi y a-t-il 6 composants supplémentaires? Il contient e (exposant public) afin que la clé RSA publique puisse être générée / extraite / dérivée de la clé RSA privée private.pem. Les 5 autres composants sont là pour accélérer le processus de décryptage. Il s'avère qu'en pré-calculant et en stockant ces 5 valeurs, il est possible d'accélérer le décryptage RSA par un facteur de 4. Le décryptage fonctionnera sans ces 5 composants, mais cela peut être fait plus rapidement si vous les avez à portée de main. L'algorithme d'accélération est basé sur le théorème des restes chinois .

Oui, la clé privée RSA private.pem contient en fait toutes ces 8 valeurs; aucun d'eux n'est généré à la volée lorsque vous exécutez la commande précédente. Essayez d'exécuter les commandes suivantes et comparez la sortie:

# 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

Cette structure de la clé privée RSA est recommandée par le PKCS # 1 v1.5 comme représentation alternative ( seconde ). La norme PKCS # 1 v2.0 exclut complètement les exposants e et d de la représentation alternative. PKCS # 1 v2.1 et v2.2 propose d'autres modifications à la représentation alternative, en incluant éventuellement plus de composants liés au CRT.

Pour voir le contenu de la clé publique RSA public.pem, exécutez ce qui suit (sortie tronquée aux étiquettes ici):

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

Modulus             - n
Exponent (public)   - e

Pas de surprise ici. C'est juste (n, e) paire, comme promis.

Répondant enfin à la question initiale: comme cela a été montré ci-dessus, la clé RSA privée générée à l'aide d'openssl contient des composants des clés publiques et privées et d'autres encore. Lorsque vous générez / extrayez / dérivez une clé publique à partir de la clé privée, openssl copie deux de ces composants (e, n) dans un fichier séparé qui devient votre clé publique.

La clé publique n'est pas stockée dans le fichier PEM comme certains le pensent. La structure DER suivante est présente dans le fichier de clé privée:

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
}

Il y a donc suffisamment de données pour calculer la clé publique (module et exposant public), ce qui openssl rsa -in mykey.pem -puboutfait

ici, dans ce code, nous créons d'abord une clé RSA qui est privée, mais elle a également une paire de sa clé publique, donc pour obtenir votre clé publique réelle, nous le faisons simplement

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

j'espère que vous l'obtiendrez pour plus d'informations vérifier cette

Tout d'abord un bref récapitulatif sur la génération de clés RSA.

1. Choisissez au hasard deux nombres premiers probables aléatoires de la taille appropriée (p et q).
2. Multipliez les deux nombres premiers ensemble pour produire le module (n).
3. Choisissez un exposant public (e).
4. Faites quelques calculs avec les nombres premiers et l'exposant public pour produire l'exposant privé (d).

La clé publique est constituée du module et de l'exposant public.

Une clé privée minimale serait constituée du module et de l'exposant privé. Il n'y a aucun moyen infaillible faisable sur le plan informatique de passer d'un module connu et d'un exposant privé à l'exposant public correspondant.

Toutefois:

1. Les formats de clé privée pratiques stockent presque toujours plus de n et d.
2. e n'est normalement pas choisi au hasard, l'une des quelques valeurs bien connues est utilisée. Si e est l'une des valeurs bien connues et que vous connaissez d, il serait facile de déterminer e par essais et erreurs.

Ainsi, dans la plupart des implémentations RSA pratiques, vous pouvez obtenir la clé publique à partir de la clé privée. Il serait possible de construire un cryptosystème basé sur RSA là où cela n'était pas possible, mais ce n'est pas chose faite.

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.