Cómo usar HTTPS con un certificado de cliente en Java
Existen varias formas de establecer una conexión segura HTTP utilizando un certificado de cliente en Java. La forma más sencilla de hacerlo es cambiando el almacén de claves (keystore) por defecto en las variables de entorno correspondientes al iniciar la JVM.
Como ejemplo, utilizaremos la siguiente Clase que realiza una conexión HTTPS e imprime algunos detalles sobre el certificado del servidor y la respuesta:
import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
import java.net.MalformedURLException;
import java.security.cert.Certificate;
import java.util.logging.Logger;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import javax.net.ssl.SSLPeerUnverifiedException;
import java.io.IOException;
public class HTTPSClient {
private static String HTTPS_URL = "https://www.google.com";
private final static Logger log = Logger.getLogger(
HTTPSClient.class.getName());
public static void main(String[] args) {
new HTTPSClient().connect();
}
private void connect() {
try {
URL url = new URL(HTTPS_URL);
HttpsURLConnection conn = (HttpsURLConnection)
url.openConnection();
conn.connect();
Certificate[] certs = conn.getServerCertificates();
if (conn != null) {
for (Certificate cert : certs) {
log.info("Cert Type: " + cert.getType());
log.info("Cert Hash Code: " + cert.hashCode());
log.info("Cert Algorithm: "
+ cert.getPublicKey().getAlgorithm());
log.info("Cert Format: " +
cert.getPublicKey().getFormat());
}
}
BufferedReader br = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
String line;
while ((line = br.readLine()) != null) {
log.info(line);
}
br.close();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (SSLPeerUnverifiedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
A continuación compilaremos el código fuente:
javac HTTPSClient.java
Como se mencionó anteriormente, para realizar una conexión HTTPS con nuestro certificado de cliente necesitaremos cambiar el almacén de claves (keystore) por defecto de la JVM ejecutando el siguiente comando:
java -Djavax.net.ssl.keyStore=/home/user/certs/user.pfx \
-Djavax.net.ssl.keyStoreType=PKCS12 \
-Djavax.net.ssl.keyStorePassword=mypassword \
HTTPSClient
En caso de que el servidor HTTP estuviera configurado con un certificado autofirmado o la CA no esté incluida en el almacén de confianza (truststore) por defecto de la JVM, la conexión fallará con una javax.net.SSLPeerUnverifiedException.
Para solucionar esto necesitaremos importar el certificado de la CA correspondiente en un nuevo almacén de confianza y decirle a la JVM que lo utilice.
Utilizaremos el comando keytool incluido con la JVM para importar el certificado de CA del servidor en el almacén de confianza mycacerts:
keytool -importcert -file /home/user/certs/myserver.pem \
-keystore /home/user/certs/mycacerts \
-storepass changeit -alias myserver
Ahora el comando para ejecutar la JVM con el almacén de confianza recién creado sería:
java -Djavax.net.ssl.keyStore=/home/user/certs/user.pfx \
-Djavax.net.ssl.keyStoreType=PKCS12 \
-Djavax.net.ssl.keyStorePassword=mypassword \
-Djavax.net.ssl.trustStore=/home/user/certs/mycacerts \
-Djavax.net.ssl.trustStorePassword=changeit \
-Djavax.net.ssl.trustStoreType=JKS \
HTTPSClient
El enfoque anterior es adecuado para realizar algunas pruebas rápidas, pero puede que necesitemos utilizar diferentes almacenes de confianza o certificados de cliente en distintas partes del código (imagina una aplicación que es cliente de varios servicios HTTPS y se necesitan diferentes certificados de cliente para cada uno).
A continuación se muestra un ejemplo de código Java que demuestra cómo personalizar el almacén de claves (keystore) y el almacén de confianza (truststore) para un cliente HTTP en particular.
No hace falta mencionar que la configuración codificada (hardcoded) debería moverse a un archivo de configuración. Esto se deja como ejercicio para el lector.
import java.net.URL;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManagerFactory;
import java.net.MalformedURLException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.util.logging.Logger;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import javax.net.ssl.SSLPeerUnverifiedException;
import java.io.IOException;
public class HTTPSClient {
private String HTTPS_URL = "https://www.google.com";
private String KEY_STORE_FILE="/home/user/certs/user.pfx";
private String KEY_STORE_PASS="mypassword";
private String TRUST_STORE_FILE="/home/user/certs/mycacerts";
private String TRUST_STORE_PASS="changeit";
//Documentado en guías de seguridad (Bajo "Nombres Estándar") tanto en JVM Oracle 7
/** Valores válidos para JVM Oracle
* - SunX509
* Valores válidos para JVM IBM
* - IbmX509
*/
private String KEY_MANAGER_ALGORITHM = "SunX509";
/** Valores válidos para JVM Oracle
* - PKCS12, JKS
* Valores válidos para JVM IBM
* - PKCS12, JKS, JCEKS
*/
private String KEY_STORE_FORMAT = "PKCS12";
private String TRUST_STORE_FORMAT = "JKS";
/** Valores válidos para JVM Oracle
* - PKIX
* Valores válidos para JVM IBM
* - PKIX o IbmPKIX o IbmX509
*/
private String TRUST_MANAGER_ALGORITHM="PKIX";
/** Valores válidos para JVM Oracle
* - SSL SSLv2 SSLv3 TLS TLSv1 TLSv1.1 TLSv1.2
* Valores válidos para JVM IBM
* - SSL SSLv3 TLS_SSL TLS TLSv1
*/
// JVM Oracle
private String SSL_CONTEXT_ALGORITHM = "TLS";
private final static Logger logger =
Logger.getLogger(HTTPSClient.class.getName());
public static void main(String[] args) {
new HTTPSClient().connect();
}
private void connect() {
try {
URL url = new URL(HTTPS_URL);
HttpsURLConnection conn = (HttpsURLConnection)
url.openConnection();
conn.setSSLSocketFactory(getFactory(new File(KEY_STORE_FILE),
KEY_STORE_PASS, new File(TRUST_STORE_FILE), TRUST_STORE_PASS));
conn.connect();
Certificate[] certs = conn.getServerCertificates();
if (conn != null) {
for (Certificate cert : certs) {
logger.info("Cert Type: " + cert.getType());
logger.info("Cert Hash Code: " + cert.hashCode());
logger.info("Cert Algorithm: " +
cert.getPublicKey().getAlgorithm());
logger.info("Cert Format: " +
cert.getPublicKey().getFormat());
}
}
BufferedReader br = new BufferedReader(new
InputStreamReader(conn.getInputStream()));
String line;
while ((line=br.readLine()) != null) {
logger.info (line);
}
br.close();
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (SSLPeerUnverifiedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
private SSLSocketFactory getFactory(File pKeyFile, String pKeyPassword,
File pTrustStoreFile, String pTrustStorePassword) {
SSLSocketFactory socketFactory = null;
try {
KeyManagerFactory keyManagerFactory;
keyManagerFactory =
KeyManagerFactory.getInstance(KEY_MANAGER_ALGORITHM);
KeyStore keyStore;
keyStore = KeyStore.getInstance(KEY_STORE_FORMAT);
InputStream keyInput = new FileInputStream(pKeyFile);
keyStore.load(keyInput, pKeyPassword.toCharArray());
keyInput.close();
keyManagerFactory.init(keyStore, pKeyPassword.toCharArray());
TrustManagerFactory trustManagerFactory =
TrustManagerFactory.getInstance(TRUST_MANAGER_ALGORITHM);
KeyStore trustStore;
trustStore = KeyStore.getInstance(TRUST_STORE_FORMAT);
InputStream trustStoreInput = new FileInputStream(pTrustStoreFile);
trustStore.load(trustStoreInput,
pTrustStorePassword.toCharArray());
trustStoreInput.close();
trustManagerFactory.init(trustStore);
SSLContext context = SSLContext.getInstance(SSL_CONTEXT_ALGORITHM);
context.init(keyManagerFactory.getKeyManagers(),
trustManagerFactory.getTrustManagers(), new SecureRandom());
socketFactory=context.getSocketFactory();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (KeyStoreException e) {
e.printStackTrace();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (CertificateException e) {
e.printStackTrace();
} catch (UnrecoverableKeyException e) {
e.printStackTrace();
} catch (KeyManagementException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return socketFactory;
}
}