Cómo importar un certificado X.509 existente y la clave privada en el almacén de claves Java para utilizar en SSL?

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

  •  05-09-2019
  •  | 
  •  

Pregunta

Tengo esto en una configuración ActiveMQ: 

<sslContext>
        <sslContext keyStore="file:/home/alex/work/amq/broker.ks"  
 keyStorePassword="password" trustStore="file:${activemq.base}/conf/broker.ts" 
 trustStorePassword="password"/>
</sslContext>

Tengo un par de certificado X.509 y un archivo de clave.

¿Cómo se importan los dos con el fin de utilizarlos en SSL y conectores SSL + pedales? Todos los ejemplos que podrían Google siempre generar la clave de sí mismos, pero ya tengo una llave.

He tratado 

keytool -import  -keystore ./broker.ks -file mycert.crt

pero esto sólo importa el certificado y no el archivo de clave y los resultados en 

2009-05-25 13:16:24,270 [localhost:61612] ERROR TransportConnector - Could not accept connection : No available certificate or key corresponds to the SSL cipher suites which are enabled.

He tratado concatenando el certificado y la clave pero obtuvo el mismo resultado.

¿Cómo se importa la tecla?

¿Fue útil?

Solución

Lo creas o no, herramienta de claves no proporciona dicha funcionalidad básica como de importar la clave privada a de almacén de claves. Puede probar este solución con la fusión de archivo PKSC12 con la clave privada de un almacén de claves.

O simplemente utilizar más fácil de usar KeyMan de IBM para la manipulación en lugar de keytool.exe almacén de claves.

Otros consejos

He utilizado los dos pasos siguientes, que he encontrado en los comentarios / mensajes vinculados en las otras respuestas:

Primer paso: Convertir el certificado X.509 y la clave a un archivo pkcs12 

openssl pkcs12 -export -in server.crt -inkey server.key \
               -out server.p12 -name [some-alias] \
               -CAfile ca.crt -caname root

Nota: Asegúrese de poner una contraseña en el archivo pkcs12 - de lo contrario obtendrá una excepción de puntero nulo cuando intenta importarlo. (En caso de que alguien más ha tenido este dolor de cabeza). ( Gracias jocull! )

Nota 2: Es posible que desee añadir la opción -chain para preservar la cadena de certificados. ( Gracias Mafuba )

Paso dos: Convertir el archivo pkcs12 a un almacén de claves de Java 

keytool -importkeystore \
        -deststorepass [changeit] -destkeypass [changeit] -destkeystore server.keystore \
        -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass some-password \
        -alias [some-alias]

Finalizado

Paso opcional cero: Crear certificado autofirmado 

openssl genrsa -out server.key 2048
openssl req -new -out server.csr -key server.key
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt

Saludos!

Keytool en Java 6 tiene esta capacidad: Importación de claves privadas en un almacén de claves Java utilizando herramienta de claves

Aquí están los detalles básicos de ese puesto.

  1. Convertir el certificado existente a un PKCS12 usando OpenSSL. Se requiere una contraseña cuando se le pregunta o el segundo paso se quejará. 

    openssl pkcs12 -export -in [my_certificate.crt] -inkey [my_key.key] -out [keystore.p12] -name [new_alias] -CAfile [my_ca_bundle.crt] -caname root

  2. Convertir el PKCS12 a un archivo de almacén de claves Java. 

    keytool -importkeystore -deststorepass [new_keystore_pass] -destkeypass [new_key_pass] -destkeystore [keystore.jks] -srckeystore [keystore.p12] -srcstoretype PKCS12 -srcstorepass [pass_used_in_p12_keystore] -alias [alias_used_in_p12_keystore]

Y una más: 

#!/bin/bash

# We have:
#
# 1) $KEY : Secret key in PEM format ("-----BEGIN RSA PRIVATE KEY-----") 
# 2) $LEAFCERT : Certificate for secret key obtained from some
#    certification outfit, also in PEM format ("-----BEGIN CERTIFICATE-----")   
# 3) $CHAINCERT : Intermediate certificate linking $LEAFCERT to a trusted
#    Self-Signed Root CA Certificate 
#
# We want to create a fresh Java "keystore" $TARGET_KEYSTORE with the
# password $TARGET_STOREPW, to be used by Tomcat for HTTPS Connector.
#
# The keystore must contain: $KEY, $LEAFCERT, $CHAINCERT
# The Self-Signed Root CA Certificate is obtained by Tomcat from the
# JDK's truststore in /etc/pki/java/cacerts

# The non-APR HTTPS connector (APR uses OpenSSL-like configuration, much
# easier than this) in server.xml looks like this 
# (See: https://tomcat.apache.org/tomcat-6.0-doc/ssl-howto.html):
#
#  <Connector port="8443" protocol="org.apache.coyote.http11.Http11Protocol"
#                SSLEnabled="true"
#                maxThreads="150" scheme="https" secure="true"
#                clientAuth="false" sslProtocol="TLS"
#                keystoreFile="/etc/tomcat6/etl-web.keystore.jks"
#                keystorePass="changeit" />
#

# Let's roll:    

TARGET_KEYSTORE=/etc/tomcat6/foo-server.keystore.jks
TARGET_STOREPW=changeit

TLS=/etc/pki/tls

KEY=$TLS/private/httpd/foo-server.example.com.key
LEAFCERT=$TLS/certs/httpd/foo-server.example.com.pem
CHAINCERT=$TLS/certs/httpd/chain.cert.pem

# ----
# Create PKCS#12 file to import using keytool later
# ----

# From https://www.sslshopper.com/ssl-converter.html:
# The PKCS#12 or PFX format is a binary format for storing the server certificate,
# any intermediate certificates, and the private key in one encryptable file. PFX
# files usually have extensions such as .pfx and .p12. PFX files are typically used 
# on Windows machines to import and export certificates and private keys.

TMPPW=$$ # Some random password

PKCS12FILE=`mktemp`

if [[ $? != 0 ]]; then
  echo "Creation of temporary PKCS12 file failed -- exiting" >&2; exit 1
fi

TRANSITFILE=`mktemp`

if [[ $? != 0 ]]; then
  echo "Creation of temporary transit file failed -- exiting" >&2; exit 1
fi

cat "$KEY" "$LEAFCERT" > "$TRANSITFILE"

openssl pkcs12 -export -passout "pass:$TMPPW" -in "$TRANSITFILE" -name etl-web > "$PKCS12FILE"

/bin/rm "$TRANSITFILE"

# Print out result for fun! Bug in doc (I think): "-pass " arg does not work, need "-passin"

openssl pkcs12 -passin "pass:$TMPPW" -passout "pass:$TMPPW" -in "$PKCS12FILE" -info

# ----
# Import contents of PKCS12FILE into a Java keystore. WTF, Sun, what were you thinking?
# ----

if [[ -f "$TARGET_KEYSTORE" ]]; then
  /bin/rm "$TARGET_KEYSTORE"
fi

keytool -importkeystore \
   -deststorepass  "$TARGET_STOREPW" \
   -destkeypass    "$TARGET_STOREPW" \
   -destkeystore   "$TARGET_KEYSTORE" \
   -srckeystore    "$PKCS12FILE" \
   -srcstoretype  PKCS12 \
   -srcstorepass  "$TMPPW" \
   -alias foo-the-server

/bin/rm "$PKCS12FILE"

# ----
# Import the chain certificate. This works empirically, it is not at all clear from the doc whether this is correct
# ----

echo "Importing chain"

TT=-trustcacerts

keytool -import $TT -storepass "$TARGET_STOREPW" -file "$CHAINCERT" -keystore "$TARGET_KEYSTORE" -alias chain

# ----
# Print contents
# ----

echo "Listing result"

keytool -list -storepass "$TARGET_STOREPW" -keystore "$TARGET_KEYSTORE"

Sí, es de hecho una herramienta de claves triste hecho de que no tiene ninguna funcionalidad para importar una clave privada.

Para el registro, en el extremo Fui con la solución descrita aquí

En primer lugar convertir a p12: 

openssl pkcs12 -export -in [filename-certificate] -inkey [filename-key] -name [host] -out [filename-new-PKCS-12.p12]

Crear nuevos JKS de p12: 

keytool -importkeystore -deststorepass [password] -destkeystore [filename-new-keystore.jks] -srckeystore [filename-new-PKCS-12.p12] -srcstoretype PKCS12

En mi caso tuve un archivo pem que contenía dos certificados y una clave privada encriptada para ser usado en la autenticación SSL mutua. Así que mi archivo PEM era la siguiente: 

-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,C8BF220FC76AA5F9
...
-----END RSA PRIVATE KEY-----
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----

Esto es lo que hice:

dividir el archivo en tres archivos separados, de modo que cada uno contiene una sola entrada, comenzando con "--- COMENZAR .." y terminando con "--- FIN .." líneas. Asumamos ahora tenemos tres archivos: cert2.pem archivo cert1.pem y pkey.pem

Convertir pkey.pem en formato DER utilizando OpenSSL y la siguiente sintaxis:

openssl pkcs8 -topk8 -nocrypt -in pkey.pem -inform PEM -out pkey.der -outform DER

Tenga en cuenta, que si se encripta la clave privada es necesario proporcionar una contraseña (obtenerla del proveedor del archivo original, pem) para convertir a formato DER, openssl le pedirá la contraseña de esta manera: "introducir un Phraze pase de pkey.pem:" Si la conversión es exitosa, se obtiene un nuevo archivo llamado "pkey.der"

Crear un nuevo almacén de claves de Java e importar la clave privada y los certificados: 

String keypass = "password";  // this is a new password, you need to come up with to protect your java key store file
String defaultalias = "importkey";
KeyStore ks = KeyStore.getInstance("JKS", "SUN");

// this section does not make much sense to me, 
// but I will leave it intact as this is how it was in the original example I found on internet:   
ks.load( null, keypass.toCharArray());
ks.store( new FileOutputStream ( "mykeystore"  ), keypass.toCharArray());
ks.load( new FileInputStream ( "mykeystore" ),    keypass.toCharArray());
// end of section..


// read the key file from disk and create a PrivateKey

FileInputStream fis = new FileInputStream("pkey.der");
DataInputStream dis = new DataInputStream(fis);
byte[] bytes = new byte[dis.available()];
dis.readFully(bytes);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

byte[] key = new byte[bais.available()];
KeyFactory kf = KeyFactory.getInstance("RSA");
bais.read(key, 0, bais.available());
bais.close();

PKCS8EncodedKeySpec keysp = new PKCS8EncodedKeySpec ( key );
PrivateKey ff = kf.generatePrivate (keysp);


// read the certificates from the files and load them into the key store:

Collection  col_crt1 = CertificateFactory.getInstance("X509").generateCertificates(new FileInputStream("cert1.pem"));
Collection  col_crt2 = CertificateFactory.getInstance("X509").generateCertificates(new FileInputStream("cert2.pem"));

Certificate crt1 = (Certificate) col_crt1.iterator().next();
Certificate crt2 = (Certificate) col_crt2.iterator().next();
Certificate[] chain = new Certificate[] { crt1, crt2 };

String alias1 = ((X509Certificate) crt1).getSubjectX500Principal().getName();
String alias2 = ((X509Certificate) crt2).getSubjectX500Principal().getName();

ks.setCertificateEntry(alias1, crt1);
ks.setCertificateEntry(alias2, crt2);

// store the private key
ks.setKeyEntry(defaultalias, ff, keypass.toCharArray(), chain );

// save the key store to a file         
ks.store(new FileOutputStream ( "mykeystore" ),keypass.toCharArray());

(opcional) Verificar el contenido de su nuevo almacén de claves:

keytool -list -keystore mykeystore -storepass password

  

Tipo de almacén de claves: JKS proveedor de almacén de claves: SUN

     

Su almacén de claves contiene 3 entradas

     

cn = ..., ou = ..., o = .., Sep 2, 2014, trustedCertEntry, Certificado   huella dactilar (SHA1): 2C: B8: ...

     

importkey, Sep 2, 2014, PrivateKeyEntry, huella digital Certificado   (SHA1): 9C: B0: ...

     

cn = ..., o = ...., Sep 2, 2014, trustedCertEntry, huella digital Certificado   (SHA1): 83:63: ...

(opcional) Ponga a prueba sus certificados y claves privadas de su nuevo almacén de claves en contra de su servidor SSL: (Es posible que desee habilitar la depuración como una opción VM: -Djavax.net.debug = todos) 

        char[] passw = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("JKS", "SUN");
        ks.load(new FileInputStream ( "mykeystore" ), passw );

        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passw);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        TrustManager[] tm = tmf.getTrustManagers();

        SSLContext sclx = SSLContext.getInstance("TLS");
        sclx.init( kmf.getKeyManagers(), tm, null);

        SSLSocketFactory factory = sclx.getSocketFactory();
        SSLSocket socket = (SSLSocket) factory.createSocket( "192.168.1.111", 443 );
        socket.startHandshake();

        //if no exceptions are thrown in the startHandshake method, then everything is fine..

Finalmente registrar sus certificados con HttpsURLConnection si va a utilizarlo: 

        char[] passw = "password".toCharArray();
        KeyStore ks = KeyStore.getInstance("JKS", "SUN");
        ks.load(new FileInputStream ( "mykeystore" ), passw );

        KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
        kmf.init(ks, passw);

        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(ks);
        TrustManager[] tm = tmf.getTrustManagers();

        SSLContext sclx = SSLContext.getInstance("TLS");
        sclx.init( kmf.getKeyManagers(), tm, null);

        HostnameVerifier hv = new HostnameVerifier()
        {
            public boolean verify(String urlHostName, SSLSession session)
            {
                if (!urlHostName.equalsIgnoreCase(session.getPeerHost()))
                {
                    System.out.println("Warning: URL host '" + urlHostName + "' is different to SSLSession host '" + session.getPeerHost() + "'.");
                }
                return true;
            }
        };

        HttpsURLConnection.setDefaultSSLSocketFactory( sclx.getSocketFactory() );
        HttpsURLConnection.setDefaultHostnameVerifier(hv);

Con base en las respuestas anteriores, aquí es cómo crear un nuevo almacén de claves para su servidor web basado en Java, de un certificado de Comodo creado de manera independiente y la clave privada utilizando herramienta de claves (requiere JDK 1.6 +)

  1. El tema este comando y en la solicitud de contraseña entran somepass - 'server.crt' es cert de su servidor y 'server.key' es la clave privada que utilizó para la emisión de la RSE: openssl pkcs12 -export -in server.crt -inkey server.key -out server.p12 -name www.yourdomain.com -CAfile AddTrustExternalCARoot.crt -caname "AddTrust External CA Root"

  2. A continuación, utilice herramienta de claves para convertir el almacén de claves de p12 en un almacén de claves JKS: keytool -importkeystore -deststorepass somepass -destkeypass somepass -destkeystore keystore.jks -srckeystore server.p12 -srcstoretype PKCS12 -srcstorepass somepass

A continuación, importe los otros dos CERT raíz / intermedios que ha recibido de Comodo:

  1. Importar COMODORSAAddTrustCA.crt: keytool -import -trustcacerts -alias cert1 -file COMODORSAAddTrustCA.crt -keystore keystore.jks

  2. Importar COMODORSADomainValidationSecureServerCA.crt: keytool -import -trustcacerts -alias cert2 -file COMODORSADomainValidationSecureServerCA.crt -keystore keystore.jks

Puede utilizar estos pasos para importar la clave de un almacén de claves existente. Las instrucciones se combinan de respuestas en este tema y otros sitios. Estas instrucciones trabajado para mí (el almacén de claves de Java):

  1. Ejecutar

openssl pkcs12 -export -in yourserver.crt -inkey yourkey.key -out server.p12 -name somename -certfile yourca.crt -caname root

(si es necesario poner la opción de cadena beta. Poniendo esto falló para mí). Esto le pedirá la contraseña - usted debe dar la contraseña correcta de lo contrario se producirá un error (Error o error de relleno, etc denominación).

  1. Se le pedirá que introduzca una nueva contraseña - debe introducir una contraseña aquí - entrar en otra cosa que recordarlo. (Supongamos que introduzca Aragorn).
  2. Esto creará el archivo server.p12 en el formato PKCS.
  3. Ahora para importar en el archivo *.jks de ejecución:
    keytool -importkeystore -srckeystore server.p12 -srcstoretype PKCS12 -destkeystore yourexistingjavakeystore.jks -deststoretype JKS -deststorepass existingjavastorepassword -destkeypass existingjavastorepassword
    (Muy importante -. No dejar de lado el deststorepass y los parámetros destkeypass)
  4. Se le preguntará por la contraseña del almacén de claves src. Introduzca Aragorn y pulsa enter. El certificado y la clave ahora se importan en el almacén de claves Java existentes.

respuestas anteriores señalan correctamente que sólo se puede hacer esto con las herramientas del JDK estándar mediante la conversión del archivo JKS en formato PKCS # 12 en primer lugar. Si está interesado, que arme una utilidad compacta importar claves derivadas de OpenSSL en un almacén de claves JKS con formato sin tener que convertir el almacén de claves PKCS # 12 a la primera: http://commandlinefanatic.com/cgi-bin/showarticle.cgi?article=art049

Se podría utilizar la utilidad ligada como esto: 

$ openssl req -x509 -newkey rsa:2048 -keyout localhost.key -out localhost.csr -subj "/CN=localhost"

(firmar la RSE, volver localhost.cer) 

$ openssl rsa -in localhost.key -out localhost.rsa
Enter pass phrase for localhost.key:
writing RSA key
$ java -classpath . KeyImport -keyFile localhost.rsa -alias localhost -certificateFile localhost.cer -keystore localhost.jks -keystorePassword changeit -keystoreType JKS -keyPassword changeit

Si usted tiene un archivo PEM (por ejemplo server.pem) que contiene:

  • el certificado de confianza
  • la clave privada

A continuación, puede importar el certificado y la clave en un almacén de claves JKS como esto:

1 ) Copia de la clave privada del archivo PEM en un archivo ASCII (por ejemplo server.key)

2 ) Copiar el cert desde el archivo de PEM en un archivo ASCII (por ejemplo server.crt)

3 ) Exportar el certificado y la clave en un archivo PKCS12: 

$ openssl pkcs12 -export -in server.crt -inkey server.key \
                 -out server.p12 -name [some-alias] -CAfile server.pem -caname root
  • el archivo PEM puede ser utilizado como el argumento de la opción -CAfile .
  • se le solicita una contraseña de 'exportación'.
  • Si haciendo esto en bash git a continuación, añadir winpty al inicio del comando para poder introducir la contraseña de exportación.

4 ) Convertir el archivo PKCS12 a un almacén de claves JKS: 

$ keytool -importkeystore -deststorepass changeit -destkeypass changeit \
          -destkeystore keystore.jks  -srckeystore server.p12 -srcstoretype PKCS12 \
          -srcstorepass changeit
  • la contraseña srcstorepass debe coincidir con la contraseña de exportación desde el paso 3)

Lo que estaba tratando de lograr fue el uso de la clave privada ya proporcionada y certificado para firmar el mensaje que se va a algún lugar que necesita para asegurarse de que el mensaje venía de mí (claves privadas firman mientras que las claves públicas cifrar).

Así que si usted ya tiene un archivo .key y un archivo .crt?

Prueba esto:

Paso 1: Convertir la clave y el certificado a .p12 

openssl pkcs12 -export -in certificate.crt -inkey privateKey.key -name alias -out yourconvertedfile.p12

Paso 2: Importe la clave y crear un archivo .jsk con un solo comando 

keytool -importkeystore -deststorepass changeit -destkeystore keystore.jks -srckeystore umeme.p12 -srcstoretype PKCS12

Paso 3: En su Java: 

char[] keyPassword = "changeit".toCharArray();

KeyStore keyStore = KeyStore.getInstance("JKS");
InputStream keyStoreData = new FileInputStream("keystore.jks");

keyStore.load(keyStoreData, keyPassword);
KeyStore.ProtectionParameter entryPassword = new KeyStore.PasswordProtection(keyPassword);
KeyStore.PrivateKeyEntry privateKeyEntry = (KeyStore.PrivateKeyEntry)keyStore.getEntry("alias", entryPassword);

System.out.println(privateKeyEntry.toString());

Si tiene que firmar un trozo de cuerda utilizando esta clave hacer lo siguiente:

Paso 1: Convertir el texto que desea cifrar 

byte[] data = "test".getBytes("UTF8");

Paso 2: Obtener base64 clave privada 

keyStore.load(keyStoreData, keyPassword);

//get cert, pubkey and private key from the store by alias
Certificate cert = keyStore.getCertificate("localhost");
PublicKey publicKey = cert.getPublicKey();
KeyPair keyPair = new KeyPair(publicKey, (PrivateKey) key);

//sign with this alg
Signature sig = Signature.getInstance("SHA1WithRSA");
sig.initSign(keyPair.getPrivate());
sig.update(data);
byte[] signatureBytes = sig.sign();
System.out.println("Signature:" + Base64.getEncoder().encodeToString(signatureBytes));

sig.initVerify(keyPair.getPublic());
sig.update(data);

System.out.println(sig.verify(signatureBytes));

Referencias:

  1. ¿Cómo importar un certificado X509 existentes y la clave privada en el almacén de claves Java para utilizar en SSL?
  2. http://tutorials.jenkov.com/java-cryptography/keystore.html
  3. http://www.java2s.com/Code/Java/Security /RetrievingaKeyPairfromaKeyStore.htm
  4. Como signo de la cuerda con la clave privada

Programa final 

public static void main(String[] args) throws Exception {

    byte[] data = "test".getBytes("UTF8");

    // load keystore
    char[] keyPassword = "changeit".toCharArray();

    KeyStore keyStore = KeyStore.getInstance("JKS");
    //System.getProperty("user.dir") + "" < for a file in particular path 
    InputStream keyStoreData = new FileInputStream("keystore.jks");
    keyStore.load(keyStoreData, keyPassword);

    Key key = keyStore.getKey("localhost", keyPassword);

    Certificate cert = keyStore.getCertificate("localhost");

    PublicKey publicKey = cert.getPublicKey();

    KeyPair keyPair = new KeyPair(publicKey, (PrivateKey) key);

    Signature sig = Signature.getInstance("SHA1WithRSA");

    sig.initSign(keyPair.getPrivate());
    sig.update(data);
    byte[] signatureBytes = sig.sign();
    System.out.println("Signature:" + Base64.getEncoder().encodeToString(signatureBytes));

    sig.initVerify(keyPair.getPublic());
    sig.update(data);

    System.out.println(sig.verify(signatureBytes));
}

Al igual que un almacén de claves PKCS12, Java puede utilizarla directamente ahora. De hecho, si anota un almacén de claves de estilo de Java, Keytool sí le alerta al hecho de que PKCS12 es ahora el formato preferido. 

openssl pkcs12 -export -in server.crt -inkey server.key \
               -out server.p12 -name [some-alias] \
               -CAfile ca.crt -caname root -chain

Debe haber recibido los tres archivos (server.crt, server.key, ca.crt) de su proveedor de certificados. No estoy seguro de lo que "raíz -caname" significa en realidad, pero parece que tienen que especificarse esa manera.

En el código de Java, asegúrese de especificar el tipo de almacén de claves derecha. 

KeyStore.getInstance("PKCS12")

Tengo mi certificado SSL comodo.com emitida por trabajar bien en NanoHTTPD esta manera.

Utilización de los certificados de Cifrar Let

Suponiendo que haya creado sus certificados y claves privadas con rel="nofollow Vamos a cifrar en /etc/letsencrypt/live/you.com:

1. Crear un PKCS # 12 archivo 

openssl pkcs12 -export -in fullchain.pem -inkey privkey.pem -out pkcs.p12 \
        -name letsencrypt

Esto combina su fullchain.pem certificado SSL y su clave privada privkey.pem en un solo archivo, pkcs.p12.

Se le pedirá una contraseña para pkcs.p12.

La opción export especifica que un archivo PKCS # 12 se creará en lugar de analizarse (de la manual).

2. Crear el almacén de claves de Java 

keytool -importkeystore -destkeystore keystore.jks -srckeystore pkcs.p12 \
        -srcstoretype PKCS12 -alias letsencrypt

Si no existe keystore.jks, se creará el archivo que contiene pkcs.12 creado anteriormente. De lo contrario, importará pkcs.12 al almacén de claves existente.

Estas instrucciones se derivan de esta entrada de blog .

Aquí hay más en los diferentes tipos de archivos en /etc/letsencrypt/live/you.com/.

en un caso de curva elíptica y responder a la pregunta Importar un certificado X509 existentes y la clave privada en el almacén de claves de Java , es posible que desee echar un vistazo también a este hilo ¿Cómo leer CE clave privada en java que está en formato de archivo .pem

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top