openssl - publica - ssh-keygen-t rsa




Use chave privada RSA para gerar chave pública? (6)

Eu realmente não entendo este aqui:

de acordo com: http://www.madboa.com/geek/openssl/#key-rsa , Você pode gerar uma chave pública a partir de uma chave privada.

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

Meu pensamento inicial foi que eles são gerados em um par juntos. A chave privada RSA contém a soma? ou a chave pública?


Pessoas procurando por chave pública SSH ...

Se você está procurando extrair a chave pública para uso com o OpenSSH, você precisará obter a chave pública um pouco diferente

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

Este formato de chave pública é compatível com o OpenSSH. Anexar a chave pública ao remote:~/.ssh/authorized_keys e você será bom para ir

docs de SSH-KEYGEN(1)

ssh-keygen -y [-f input_keyfile]  

-y Essa opção lerá um arquivo no formato OpenSSH particular e imprimirá uma chave pública OpenSSH para stdout.


A chave pública não é armazenada no arquivo PEM como algumas pessoas pensam. A seguinte estrutura DER está presente no arquivo de chave particular:

openssl rsa -text -em 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
}

Portanto, há dados suficientes para calcular a chave pública (módulo e expoente público), que é o que openssl rsa -in mykey.pem -pubout faz


Minha resposta abaixo é um pouco longa, mas espero que forneça alguns detalhes que estão faltando nas respostas anteriores. Vou começar com algumas declarações relacionadas e finalmente responder à pergunta inicial.

Para criptografar algo usando o algoritmo RSA, você precisa de par expoente de módulo (criptografia) e criptografia (n, e). Essa é sua chave pública. Para descriptografar algo usando o algoritmo RSA, você precisa do par de expoente de módulo (decrescente) (n, d). Essa é sua chave privada.

Para criptografar algo usando a chave pública RSA, você trata seu texto simples como um número e o eleva ao poder do módulo e:

ciphertext = ( plaintext^e ) mod n

Para descriptografar algo usando a chave privada RSA, você trata o seu texto cifrado como um número e o eleva ao poder do módulo d n:

plaintext = ( ciphertext^d ) mod n

Para gerar chaves privadas (d, n) usando o openssl, você pode usar o seguinte comando:

openssl genrsa -out private.pem 1024

Para gerar chave pública (e, n) a partir da chave privada usando o openssl, você pode usar o seguinte comando:

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

Para dissecar o conteúdo da chave privada RSA private.pem gerada pelo comando openssl acima, execute o seguinte (saída truncada para rótulos aqui):

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

A chave privada não deve consistir apenas em pares (n, d)? Por que existem 6 componentes extras? Ele contém e (expoente público) para que a chave RSA pública possa ser gerada / extraída / derivada da chave privada RSA private.pem. Os outros 5 componentes estão lá para acelerar o processo de descriptografia. Acontece que pré-computando e armazenando esses 5 valores é possível acelerar a descriptografia RSA pelo fator de 4. A descriptografia funcionará sem esses 5 componentes, mas isso pode ser feito mais rápido se você os tiver à mão. O algoritmo de aceleração é baseado no Teorema Chinês do Restante .

Sim, private.pem A chave privada RSA contém na verdade todos esses 8 valores; nenhum deles é gerado na hora quando você executa o comando anterior. Tente executar os seguintes comandos e comparar a saída:

# 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

Essa estrutura da chave privada RSA é recomendada pelo PKCS # 1 v1.5 como uma representação alternativa ( segunda ). O padrão PKCS # 1 v2.0 exclui totalmente os expoentes e e d da representação alternativa. Os PKCS # 1 v2.1 e v2.2 propõem mais alterações na representação alternativa, incluindo, opcionalmente, mais componentes relacionados ao CRT.

Para ver o conteúdo da chave pública RSA public.pem, execute o seguinte (saída truncada para rótulos aqui):

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

Modulus             - n
Exponent (public)   - e

Nenhuma surpresa aqui. É apenas par (n, e), como prometido.

Agora finalmente respondendo a pergunta inicial: Como foi mostrado acima, a chave RSA privada gerada usando openssl contém componentes de chaves públicas e privadas e um pouco mais. Ao gerar / extrair / derivar chave pública da chave privada, o openssl copia dois desses componentes (e, n) em um arquivo separado que se torna sua chave pública.


Na maioria dos softwares que geram chaves privadas RSA, incluindo as de openssl, a chave privada é representada como um objeto RSAPrivatekey PKCS # 1 ou alguma variante dele:

A.1.2 sintaxe de chave privada RSA

Uma chave privada RSA deve ser representada com o 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
  }

Como você pode ver, esse formato tem vários campos, incluindo o módulo e o expoente público, sendo, portanto, um superconjunto estrito das informações em uma chave pública RSA .


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.

openssl genrsa -out mykey.pem 1024

irá realmente produzir um par de chaves pública-privada. O par é armazenado no arquivo mykey.pem gerado.

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

irá extrair a chave pública e imprimi-la. Here está um link para uma página que descreve isso melhor.

EDIT: Confira a seção de exemplos here . Para apenas produzir a parte pública de uma chave privada:

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