Convertendo um Java Keystore em formato PEM

StackOverflow https://stackoverflow.com/questions/652916

Pergunta

Eu estou tentando converter de um arquivo de armazenamento de chave Java em um arquivo PEM usando keytool e OpenSSL applicactions. Mas eu não poderia encontrar uma boa maneira de fazer a conversão. Alguma ideia?

Em vez de converter o armazenamento de chaves diretamente no PEM Eu tentei criar um arquivo PKCS12 primeiro e depois converter em arquivo PEM relevante e armazenamento de chaves. Mas eu não poderia estabelecer uma conexão usando-los. (Note que eu só preciso de um arquivo PEM e um arquivo de armazenamento de chaves para implementar uma conexão segura. Não há nenhuma restrição, como "Iniciar a partir de um arquivo de armazenamento de chave java". :) Então, a partir de outros formatos é aceitável com o meu caso)

Mas um método de conversão direta de JKS para pem é preferível.

Foi útil?

Solução

É bastante simples, usando jdk6 pelo menos ... 

bash$ keytool -keystore foo.jks -genkeypair -alias foo \
        -dname 'CN=foo.example.com,L=Melbourne,ST=Victoria,C=AU'
Enter keystore password:  
Re-enter new password: 
Enter key password for 
        (RETURN if same as keystore password):  
bash$ keytool -keystore foo.jks -exportcert -alias foo | \
       openssl x509 -inform der -text
Enter keystore password:  asdasd
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 1237334757 (0x49c03ae5)
        Signature Algorithm: dsaWithSHA1
        Issuer: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Validity
            Not Before: Mar 18 00:05:57 2009 GMT
            Not After : Jun 16 00:05:57 2009 GMT
        Subject: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Subject Public Key Info:
            Public Key Algorithm: dsaEncryption
            DSA Public Key:
                pub: 
                    00:e2:66:5c:e0:2e:da:e0:6b:a6:aa:97:64:59:14:
                    7e:a6:2e:5a:45:f9:2f:b5:2d:f4:34:27:e6:53:c7:
 

bash$ keytool -importkeystore -srckeystore foo.jks \
       -destkeystore foo.p12 \
       -srcstoretype jks \
       -deststoretype pkcs12
Enter destination keystore password:  
Re-enter new password: 
Enter source keystore password:  
Entry for alias foo successfully imported.
Import command completed:  1 entries successfully imported, 0 entries failed or cancelled

bash$ openssl pkcs12 -in foo.p12 -out foo.pem
Enter Import Password:
MAC verified OK
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:

bash$ openssl x509 -text -in foo.pem
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 1237334757 (0x49c03ae5)
        Signature Algorithm: dsaWithSHA1
        Issuer: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Validity
            Not Before: Mar 18 00:05:57 2009 GMT
            Not After : Jun 16 00:05:57 2009 GMT
        Subject: C=AU, ST=Victoria, L=Melbourne, CN=foo.example.com
        Subject Public Key Info:
            Public Key Algorithm: dsaEncryption
            DSA Public Key:
                pub: 
                    00:e2:66:5c:e0:2e:da:e0:6b:a6:aa:97:64:59:14:
                    7e:a6:2e:5a:45:f9:2f:b5:2d:f4:34:27:e6:53:c7:
 

bash$ openssl dsa -text -in foo.pem
read DSA key
Enter PEM pass phrase:
Private-Key: (1024 bit)
priv:
    00:8f:b1:af:55:63:92:7c:d2:0f:e6:f3:a2:f5:ff:
    1a:7a:fe:8c:39:dd
pub: 
    00:e2:66:5c:e0:2e:da:e0:6b:a6:aa:97:64:59:14:
    7e:a6:2e:5a:45:f9:2f:b5:2d:f4:34:27:e6:53:c7:

Você acaba com:

  • foo.jks -. Keystore em formato java
  • foo.p12 - armazenamento de chaves no formato PKCS # 12
    • .
  • foo.pem -. Todas as chaves e certificados de armazenamento de chaves, no formato PEM

(Este último arquivo pode ser dividido em chaves e certificados, se quiser.)

resumo de comando - para criar armazenamento de chave JKS: 

keytool -keystore foo.jks -genkeypair -alias foo \
    -dname 'CN=foo.example.com,L=Melbourne,ST=Victoria,C=AU'

resumo de comando - para converter armazenamento de chave JKS em PKCS # 12 armazenamento de chaves, em seguida, em arquivo PEM: 

keytool -importkeystore -srckeystore foo.jks \
   -destkeystore foo.p12 \
   -srcstoretype jks \
   -deststoretype pkcs12

openssl pkcs12 -in foo.p12 -out foo.pem

Se você tem mais de um certificado em seus armazenamento de chave JKS, e você quer apenas para exportar o certificado ea chave associada com um dos aliases, você pode usar a seguinte variação: 

keytool -importkeystore -srckeystore foo.jks \
   -destkeystore foo.p12 \
   -srcalias foo \
   -srcstoretype jks \
   -deststoretype pkcs12

openssl pkcs12 -in foo.p12 -out foo.pem

resumo de comando - para comparar JKS armazenamento de chaves para arquivo PEM: 

keytool -keystore foo.jks -exportcert -alias foo | \
   openssl x509 -inform der -text

openssl x509 -text -in foo.pem

openssl dsa -text -in foo.pem

Outras dicas

eu continuei recebendo erros de openssl ao usar o comando de StoBor: 

MAC verified OK
Error outputting keys and certificates
139940235364168:error:06065064:digital envelope routines:EVP_DecryptFinal_ex:bad decrypt:evp_enc.c:535:
139940235364168:error:23077074:PKCS12 routines:PKCS12_pbe_crypt:pkcs12 cipherfinal error:p12_decr.c:97:
139940235364168:error:2306A075:PKCS12 routines:PKCS12_item_decrypt_d2i:pkcs12 pbe crypt error:p12_decr.c:123:

Por alguma razão, só que desta estilo de comando iria trabalhar para o meu arquivo JKS 

keytool -importkeystore -srckeystore foo.jks \
   -destkeystore foo.p12 \
   -srcstoretype jks \
   -srcalias mykey \
   -deststoretype pkcs12 \
   -destkeypass DUMMY123

A chave foi a criação destkeypass, o valor do argumento não importava.

O comando keytool não lhe permitirá exportar a chave privada a partir de um armazenamento de chaves. Você tem que escrever algum código Java para fazer isso. Abra o armazenamento de chaves, pegar a chave que você precisa, e guardá-lo para um arquivo no formato PKCS # 8. Salvar o certificado associado também. 

KeyStore ks = KeyStore.getInstance("jks");
/* Load the key store. */
...
char[] password = ...;
/* Save the private key. */
FileOutputStream kos = new FileOutputStream("tmpkey.der");
Key pvt = ks.getKey("your_alias", password);
kos.write(pvt.getEncoded());
kos.flush();
kos.close();
/* Save the certificate. */
FileOutputStream cos = new FileOutputStream("tmpcert.der");
Certificate pub = ks.getCertificate("your_alias");
cos.write(pub.getEncoded());
cos.flush();
cos.close();

utilitários Use OpenSSL para converter esses arquivos (que são em formato binário) para o formato PEM. 

openssl pkcs8 -inform der -nocrypt < tmpkey.der > tmpkey.pem
openssl x509 -inform der < tmpcert.der > tmpcert.pem

A conversão direta de JKS para o arquivo pem usando o keytool 

keytool -exportcert -alias selfsigned -keypass password -keystore test-user.jks -rfc -file test-user.pem

instruções Simplificado para converte um arquivo JKS a PEM eo formato CHAVE (.crt & .key): 

keytool -importkeystore -srckeystore <Source-Java-Key-Store-File> -destkeystore <Destination-Pkcs12-File> -srcstoretype jks -deststoretype pkcs12 -destkeypass <Destination-Key-Password>

openssl pkcs12 -in <Destination-Pkcs12-File> -out <Destination-Pem-File>

openssl x509 -outform der -in <Destination-Pem-File> -out <Destination-Crt-File>

openssl rsa -in <Destination-Pem-File> -out <Destination-Key-File>

Eu encontrei uma solução muito interessante:

http://www.swview.org/node/191

Em seguida, dividi o par de chaves pública / privada em dois arquivos publi.pem private.key e funciona!

Bem, OpenSSL deve fazê-lo com folga de um arquivo # 12: 

openssl pkcs12 -in pkcs-12-certificate-file -out pem-certificate-file
openssl pkcs12 -in pkcs-12-certificate-and-key-file -out pem-certificate-and-key-file

Talvez mais detalhes sobre o que o erro / fracasso é?

A conversão de um armazenamento de chave JKS para um único arquivo PEM pode ser facilmente realizado usando o comando a seguir: 

keytool -list -rfc -keystore "myKeystore.jks" | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d" >> "myKeystore.pem"

Explicação:

  1. listas keytool -list -rfc -keystore "myKeystore.jks" tudo no KeyStore 'myKeyStore.jks' em formato PEM. No entanto, também imprime informações extra.
  2. | sed -e "/-*BEGIN [A-Z]*-*/,/-*END [A-Z]-*/!d" filtra tudo o que não precisa. Nós somos deixados apenas com os PEMs de tudo no armazenamento de chaves.
  3. >> "myKeystore.pem" write as PEMs para o arquivo 'myKeyStore.pem'.

No caso de você não ter OpenSSL instalado e você está procurando uma solução rápida, há um software chamado portcle que é muito útil e pequeno para download.

A desvantagem é que não há nenhuma linha de comando, tanto quanto eu sei. Mas a partir da GUI, é bastante simples para exportar uma chave privada PEM:

  1. Open você JKS armazenamento de chaves
  2. clique com o botão direito sobre a entrada de chave privada e selecione Exportar

  3. Selecionar Chave Privada e certificados e formato PEM

    Exportar PEM chave privada do JKS com Portcle

Tente Keystore Explorador http://keystore-explorer.org/

KeyStore Explorer é um substituto GUI código aberto para a linha de comando Java utilitários keytool e jarsigner. Ele faz openssl / pkcs12 também.

primeiro criar o arquivo de armazenamento de chave como

C: \ Program Files \ Android \ Android Studio \ jre \ bin> keytool -keystore androidkey.jks -genkeypair -alias androidkey

Digite a senha de armazenamento de chaves:
Re-digite a nova senha:
Qual é o seu primeiro e último nome? Desconhecido: Nome Sobrenome
Qual o nome da sua unidade organizacional? Desconhecido: Desenvolvimento Móvel
Qual é o nome da sua organização? Desconhecido: o nome da empresa
Qual é o nome de sua cidade ou localidade? Qual é o nome de seu estado ou província?
Qual é o código de duas letras para esta unidade? Desconhecido: IN // pressione enter

Agora ele irá pedir para confirmar

é CN = Nome Sobrenome, OU = Desenvolvimento Mobile, O = o nome da empresa, L = CityName, ST = StateName, C = IN correto? [No]: Sim

Digite a senha chave para (RETURN se mesmo que a senha de armazenamento de chave): pressione enter se você quiser mesma senha

chave foi gerada, agora você pode simplesmente obter o arquivo pem usando seguinte comando

C: \ Program Files \ Android \ Android Studio \ jre \ bin> keytool -export -rfc -alias androidkey -file android_certificate.pem -keystore androidkey.jks
Digite a senha de armazenamento de chaves:
Certificado armazenado no arquivo

Primeiro despejar o armazenamento de chaves de JKS para PKCS12

1. keytool -importkeystore -srckeystore ~ ??/ .android / debug.keystore -destkeystore intermediate.p12 -srcstoretype JKS -deststoretype PKCS12

Despejar o novo arquivo pkcs12 em pem

  1. openssl pkcs12 -in intermediate.p12 -nodes out intermediate.rsa.pem

Você deve ter tanto o certificado ea chave privada no formato PEM. Separá-los. Coloque a parte entre “BEGIN CERTIFICADO” e “certificado END” em cert.x509.pem Coloque a parte entre “BEGIN RSA PRIVATE KEY” e “END RSA PRIVATE KEY” em private.rsa.pem Converter a chave privada em formato pk8 como esperado por signapk

3. openssl PKCS8 -topk8 -outform DER -in private.rsa.pem -Informar PEM out private.pk8 -nocrypt

A conversão de um Java Keystore em formato PEM

A resposta mais precisa de todos deve ser que isso não é possível.

keystore A Java é apenas uma instalação de armazenamento para chaves criptográficas e certificados enquanto PEM é um formato de arquivo por apenas X.509 certificados.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top