Utilizzare la chiave privata RSA per generare la chiave pubblica?

Non capisco davvero questo:

secondo: http://www.madboa.com/geek/openssl/#key-rsa , è possibile generare una chiave pubblica da una chiave privata.

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

Il mio pensiero iniziale era che fossero generati in coppia insieme. La chiave privata RSA contiene la somma? o la chiave pubblica?

openssl genrsa -out mykey.pem 1024

produrrà effettivamente una coppia di chiavi pubblica - privata. La coppia è memorizzata nel mykey.pemfile generato .

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

estrarrà la chiave pubblica e la stamperà. Ecco un link a una pagina che lo descrive meglio.

EDIT: controlla qui la sezione degli esempi . Per generare semplicemente la parte pubblica di una chiave privata:

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

Per ottenere una chiave pubblica utilizzabile per scopi SSH, utilizzare ssh-keygen :

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

Persone in cerca di chiave pubblica SSH ...

Se stai cercando di estrarre la chiave pubblica da utilizzare con OpenSSH, dovrai ottenere la chiave pubblica in modo leggermente diverso

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

Questo formato di chiave pubblica è compatibile con OpenSSH. Aggiungi la chiave pubblica a remote:~/.ssh/authorized_keyse sarai a posto

documenti di SSH-KEYGEN(1)

ssh-keygen -y [-f input_keyfile]  

-y Questa opzione leggerà un file privato in formato OpenSSH e stamperà una chiave pubblica OpenSSH su stdout.

Nella maggior parte dei software che generano chiavi private RSA, comprese quelle di openssl, la chiave privata è rappresentata come un oggetto RSAPrivatekey PKCS # 1 o una sua variante:

A.1.2 Sintassi della chiave privata RSA

Una chiave privata RSA deve essere rappresentata con il tipo 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
  }

Come puoi vedere, questo formato ha una serie di campi tra cui il modulo e l'esponente pubblico e quindi è un superset rigoroso delle informazioni in una chiave pubblica RSA .

La mia risposta di seguito è un po 'lunga, ma si spera che fornisca alcuni dettagli che mancano nelle risposte precedenti. Inizierò con alcune dichiarazioni correlate e alla fine risponderò alla domanda iniziale.

Per crittografare qualcosa usando l'algoritmo RSA hai bisogno di modulo e coppia di esponenti di crittografia (pubblica) (n, e). Questa è la tua chiave pubblica. Per decrittografare qualcosa usando l'algoritmo RSA sono necessarie la coppia di esponenti modulo (e privata) (n, d). Questa è la tua chiave privata.

Per crittografare qualcosa usando la chiave pubblica RSA, tratti il ​​tuo testo in chiaro come un numero e lo elevi alla potenza di e modulo:

ciphertext = ( plaintext^e ) mod n

Per decrittografare qualcosa usando la chiave privata RSA, tratti il ​​tuo testo cifrato come un numero e lo elevi alla potenza di d modulo n:

plaintext = ( ciphertext^d ) mod n

Per generare la chiave privata (d, n) usando openssl puoi usare il seguente comando:

openssl genrsa -out private.pem 1024

Per generare la chiave pubblica (e, n) dalla chiave privata usando openssl puoi usare il seguente comando:

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

Per analizzare il contenuto della chiave RSA privata private.pem generata dal comando openssl sopra, eseguire quanto segue (output troncato alle etichette qui):

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 chiave privata non dovrebbe essere composta solo da (n, d) coppia? Perché ci sono 6 componenti extra? Contiene e (esponente pubblico) in modo che la chiave RSA pubblica possa essere generata / estratta / derivata dalla chiave RSA privata private.pem. I restanti 5 componenti sono lì per accelerare il processo di decrittazione. Si scopre che pre-calcolando e memorizzando quei 5 valori è possibile velocizzare la decrittazione RSA del fattore 4. La decodifica funzionerà senza quei 5 componenti, ma può essere eseguita più velocemente se li si ha a portata di mano. L'algoritmo di accelerazione si basa sul teorema del resto cinese .

Sì, la chiave privata RSA private.pem contiene effettivamente tutti questi 8 valori; nessuno di questi viene generato al volo quando si esegue il comando precedente. Prova a eseguire i seguenti comandi e confronta l'output:

# 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

Questa struttura della chiave privata RSA è consigliata da PKCS # 1 v1.5 come alternativa ( seconda ) rappresentazione. Lo standard PKCS # 1 v2.0 esclude del tutto gli esponenti e e dalla rappresentazione alternativa. PKCS # 1 v2.1 e v2.2 propongono ulteriori modifiche alla rappresentazione alternativa, includendo facoltativamente più componenti relative a CRT.

Per visualizzare il contenuto della chiave pubblica RSA public.pem, eseguire quanto segue (output troncato alle etichette qui):

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

Modulus             - n
Exponent (public)   - e

Nessuna sorpresa qui. È solo una coppia (n, e), come promesso.

Ora finalmente rispondo alla domanda iniziale: Come è stato mostrato sopra, la chiave RSA privata generata usando openssl contiene componenti di chiavi sia pubbliche che private e altro ancora. Quando si genera / estrae / deriva la chiave pubblica dalla chiave privata, openssl copia due di questi componenti (e, n) in un file separato che diventa la chiave pubblica.

La chiave pubblica non è memorizzata nel file PEM come pensano alcune persone. La seguente struttura DER è presente nel file della chiave privata:

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
}

Quindi ci sono abbastanza dati per calcolare la chiave pubblica (modulo ed esponente pubblico), che è ciò che openssl rsa -in mykey.pem -puboutfa

qui in questo codice per prima cosa stiamo creando una chiave RSA che è privata ma ha anche una coppia della sua chiave pubblica, quindi per ottenere la tua chiave pubblica effettiva facciamo semplicemente questo

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

spero di averlo per maggiori informazioni controlla questo

Innanzitutto un rapido riepilogo sulla generazione delle chiavi RSA.

1. Scegli casualmente due numeri primi probabili casuali della dimensione appropriata (peq).
2. Moltiplica i due numeri primi insieme per produrre il modulo (n).
3. Scegli un esponente pubblico (e).
4. Fai un po 'di matematica con i numeri primi e l'esponente pubblico per produrre l'esponente privato (d).

La chiave pubblica è costituita dal modulo e dall'esponente pubblico.

Una chiave privata minima consisterebbe nel modulo e nell'esponente privato. Non esiste un modo sicuro computazionalmente fattibile per passare da un modulo noto e un esponente privato al corrispondente esponente pubblico.

Però:

1. Pratici formati di chiave privata memorizzano quasi sempre più di n e d.
2. Normalmente non viene scelto in modo casuale, viene utilizzato uno dei pochi valori noti. Se e è uno dei valori noti e conosci d allora sarebbe facile capire e per tentativi ed errori.

Quindi nella maggior parte delle implementazioni pratiche di RSA puoi ottenere la chiave pubblica dalla chiave privata. Sarebbe possibile costruire un cryptosystem basato su RSA dove ciò non era possibile, ma non è una cosa fatta.

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.