Authentification par certificat client HTTPS Java

Je suis assez nouveau HTTPS/SSL/TLSet je suis un peu confus sur ce que les clients sont censés présenter exactement lors de l'authentification avec des certificats.

J'écris un client Java qui doit faire un simple POSTde données à un particulier URL. Cette partie fonctionne bien, le seul problème est qu'elle est censée être terminée HTTPS. La HTTPSpartie est assez facile à manipuler (avec HTTPclientou en utilisant le HTTPSsupport intégré de Java ), mais je suis bloqué sur l'authentification avec les certificats clients. J'ai remarqué qu'il y a déjà une question très similaire ici, que je n'ai pas encore essayée avec mon code (le fera assez tôt). Mon problème actuel est que - quoi que je fasse - le client Java n'envoie jamais le certificat (je peux le vérifier avec des PCAPvidages).

Je voudrais savoir exactement ce que le client est censé présenter au serveur lors de l'authentification avec des certificats (spécifiquement pour Java - si cela est important)? Est-ce un JKSfichier, ou PKCS#12? Ce qui est censé être en eux; juste le certificat client ou une clé? Si oui, quelle clé? Il y a pas mal de confusion sur tous les différents types de fichiers, les types de certificats et autres.

Comme je l'ai déjà dit, je suis novice, HTTPS/SSL/TLSdonc j'apprécierais également quelques informations de base (ne doit pas être un essai; je me contenterai de liens vers de bons articles).

Enfin réussi à résoudre tous les problèmes, je vais donc répondre à ma propre question. Ce sont les paramètres / fichiers que j'ai utilisés pour gérer la résolution de mes problèmes particuliers;

Le fichier de clés du client est un fichier au format PKCS # 12 contenant

1. Le certificat public du client (dans ce cas, signé par une autorité de certification auto-signée)
2. La clé privée du client

Pour le générer, j'ai utilisé la pkcs12commande d'OpenSSL , par exemple;

openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12 -name "Whatever"

Astuce: assurez-vous d'obtenir la dernière version d' OpenSSL, pas la version 0.9.8h car cela semble souffrir d'un bogue qui ne vous permet pas de générer correctement les fichiers PKCS # 12.

Ce fichier PKCS # 12 sera utilisé par le client Java pour présenter le certificat client au serveur lorsque le serveur a explicitement demandé au client de s'authentifier. Voir l'article Wikipedia sur TLS pour un aperçu du fonctionnement du protocole d'authentification par certificat client (explique également pourquoi nous avons besoin de la clé privée du client ici).

Le fichier de clés certifiées du client est un fichier au format JKS simple contenant les certificats d'autorité de certification racine ou intermédiaire . Ces certificats d'autorité de certification détermineront les points de terminaison avec lesquels vous serez autorisé à communiquer, dans ce cas, ils permettront à votre client de se connecter au serveur qui présente un certificat signé par l'une des autorités de certification du magasin de clés de confiance.

Pour le générer, vous pouvez utiliser le keytool Java standard, par exemple;

keytool -genkey -dname "cn=CLIENT" -alias truststorekey -keyalg RSA -keystore ./client-truststore.jks -keypass whatever -storepass whatever
keytool -import -keystore ./client-truststore.jks -file myca.crt -alias myca

À l'aide de ce magasin de clés de confiance, votre client essaiera d'effectuer une négociation SSL complète avec tous les serveurs qui présentent un certificat signé par l'autorité de certification identifiée par myca.crt.

Les fichiers ci-dessus sont strictement réservés au client. Lorsque vous souhaitez également configurer un serveur, le serveur a besoin de ses propres fichiers de clés et de fichiers de clés certifiées. Une grande procédure pas à pas pour configurer un exemple pleinement fonctionnel pour un client et un serveur Java (à l'aide de Tomcat) peut être trouvée sur ce site Web .

Problèmes / remarques / conseils

1. L'authentification du certificat client ne peut être appliquée que par le serveur.
2. ( Important! ) Lorsque le serveur demande un certificat client (dans le cadre de la négociation TLS), il fournit également une liste des autorités de certification approuvées dans le cadre de la demande de certificat. Lorsque le certificat client que vous souhaitez présenter pour l'authentification n'est pas signé par l'une de ces autorités de certification, il ne sera pas présenté du tout (à mon avis, c'est un comportement étrange, mais je suis sûr qu'il y a une raison à cela). C'était la principale cause de mes problèmes, car l'autre partie n'avait pas configuré correctement son serveur pour accepter mon certificat client auto-signé et nous avons supposé que le problème était de mon côté pour ne pas fournir correctement le certificat client dans la demande.
3. Obtenez Wireshark. Il a une excellente analyse des paquets SSL / HTTPS et sera une aide considérable pour le débogage et la recherche du problème. Il est similaire -Djavax.net.debug=sslmais plus structuré et (sans doute) plus facile à interpréter si vous n'êtes pas à l'aise avec la sortie de débogage SSL SSL.

4. Il est parfaitement possible d'utiliser la bibliothèque Apache httpclient. Si vous souhaitez utiliser httpclient, remplacez simplement l'URL de destination par l'équivalent HTTPS et ajoutez les arguments JVM suivants (qui sont les mêmes pour tout autre client, quelle que soit la bibliothèque que vous souhaitez utiliser pour envoyer / recevoir des données via HTTP / HTTPS) :

   -Djavax.net.debug=ssl
   -Djavax.net.ssl.keyStoreType=pkcs12
   -Djavax.net.ssl.keyStore=client.p12
   -Djavax.net.ssl.keyStorePassword=whatever
   -Djavax.net.ssl.trustStoreType=jks
   -Djavax.net.ssl.trustStore=client-truststore.jks
   -Djavax.net.ssl.trustStorePassword=whatever

D'autres réponses montrent comment configurer globalement les certificats clients. Cependant, si vous souhaitez définir par programme la clé client pour une connexion particulière, plutôt que de la définir globalement dans chaque application exécutée sur votre machine virtuelle Java, vous pouvez configurer votre propre SSLContext comme suit:

String keyPassphrase = "";

KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(new FileInputStream("cert-key-pair.pfx"), keyPassphrase.toCharArray());

SSLContext sslContext = SSLContexts.custom()
        .loadKeyMaterial(keyStore, null)
        .build();

HttpClient httpClient = HttpClients.custom().setSSLContext(sslContext).build();
HttpResponse response = httpClient.execute(new HttpGet("https://example.com"));

Le fichier JKS n'est qu'un conteneur de certificats et de paires de clés. Dans un scénario d'authentification côté client, les différentes parties des clés seront situées ici:

• Le client « magasin de contiendra du client public et privé paire de clés. Il s'agit d'un magasin de clés .
• Le magasin du serveur contiendra la clé publique du client . Il s'agit d'un magasin de confiance .

La séparation de truststore et keystore n'est pas obligatoire mais recommandée. Il peut s'agir du même fichier physique.

Pour définir les emplacements du système de fichiers des deux magasins, utilisez les propriétés système suivantes:

-Djavax.net.ssl.keyStore=clientsidestore.jks

et sur le serveur:

-Djavax.net.ssl.trustStore=serversidestore.jks

Pour exporter le certificat du client (clé publique) dans un fichier, afin de pouvoir le copier sur le serveur, utilisez

keytool -export -alias MYKEY -file publicclientkey.cer -store clientsidestore.jks

Pour importer la clé publique du client dans le magasin de clés du serveur, utilisez (comme l'affiche l'a mentionné, cela a déjà été fait par les administrateurs du serveur)

keytool -import -file publicclientkey.cer -store serversidestore.jks

Maven pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>some.examples</groupId>
    <artifactId>sslcliauth</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>sslcliauth</name>
    <dependencies>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.4</version>
        </dependency>
    </dependencies>
</project>

Code Java:

package some.examples;

import java.io.FileInputStream;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.http.entity.InputStreamEntity;

public class SSLCliAuthExample {

private static final Logger LOG = Logger.getLogger(SSLCliAuthExample.class.getName());

private static final String CA_KEYSTORE_TYPE = KeyStore.getDefaultType(); //"JKS";
private static final String CA_KEYSTORE_PATH = "./cacert.jks";
private static final String CA_KEYSTORE_PASS = "changeit";

private static final String CLIENT_KEYSTORE_TYPE = "PKCS12";
private static final String CLIENT_KEYSTORE_PATH = "./client.p12";
private static final String CLIENT_KEYSTORE_PASS = "changeit";

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

public final static void requestTimestamp() throws Exception {
    SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(
            createSslCustomContext(),
            new String[]{"TLSv1"}, // Allow TLSv1 protocol only
            null,
            SSLConnectionSocketFactory.getDefaultHostnameVerifier());
    try (CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(csf).build()) {
        HttpPost req = new HttpPost("https://changeit.com/changeit");
        req.setConfig(configureRequest());
        HttpEntity ent = new InputStreamEntity(new FileInputStream("./bytes.bin"));
        req.setEntity(ent);
        try (CloseableHttpResponse response = httpclient.execute(req)) {
            HttpEntity entity = response.getEntity();
            LOG.log(Level.INFO, "*** Reponse status: {0}", response.getStatusLine());
            EntityUtils.consume(entity);
            LOG.log(Level.INFO, "*** Response entity: {0}", entity.toString());
        }
    }
}

public static RequestConfig configureRequest() {
    HttpHost proxy = new HttpHost("changeit.local", 8080, "http");
    RequestConfig config = RequestConfig.custom()
            .setProxy(proxy)
            .build();
    return config;
}

public static SSLContext createSslCustomContext() throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException, KeyManagementException, UnrecoverableKeyException {
    // Trusted CA keystore
    KeyStore tks = KeyStore.getInstance(CA_KEYSTORE_TYPE);
    tks.load(new FileInputStream(CA_KEYSTORE_PATH), CA_KEYSTORE_PASS.toCharArray());

    // Client keystore
    KeyStore cks = KeyStore.getInstance(CLIENT_KEYSTORE_TYPE);
    cks.load(new FileInputStream(CLIENT_KEYSTORE_PATH), CLIENT_KEYSTORE_PASS.toCharArray());

    SSLContext sslcontext = SSLContexts.custom()
            //.loadTrustMaterial(tks, new TrustSelfSignedStrategy()) // use it to customize
            .loadKeyMaterial(cks, CLIENT_KEYSTORE_PASS.toCharArray()) // load client certificate
            .build();
    return sslcontext;
}

}

Pour ceux d'entre vous qui souhaitent simplement configurer une authentification bidirectionnelle (certificats serveur et client), une combinaison de ces deux liens vous y mènera:

Configuration d'authentification bidirectionnelle:

https://linuxconfig.org/apache-web-server-ssl-authentication

Vous n'avez pas besoin d'utiliser le fichier de configuration openssl qu'ils mentionnent; il suffit d'utiliser

• $ openssl genrsa -des3 -out ca.key 4096

• $ openssl req -new -x509 -days 365 -key ca.key -out ca.crt

pour générer votre propre certificat CA, puis générer et signer les clés de serveur et de client via:

• $ openssl genrsa -des3 -out server.key 4096

• $ openssl req -new -key server.key -out server.csr

• $ openssl x509 -req -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 100 -out server.crt

et

• $ openssl genrsa -des3 -out client.key 4096

• $ openssl req -new -key client.key -out client.csr

• $ openssl x509 -req -days 365 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 101 -out client.crt

Pour le reste, suivez les étapes du lien. La gestion des certificats pour Chrome fonctionne de la même manière que dans l'exemple de Firefox qui est mentionné.

Ensuite, configurez le serveur via:

https://www.digitalocean.com/community/tutorials/how-to-create-a-ssl-certificate-on-apache-for-ubuntu-14-04

Notez que vous avez déjà créé le serveur .crt et .key afin que vous n'ayez plus à faire cette étape.

Je me suis connecté à une banque avec SSL bidirectionnel (certificat client et serveur) avec Spring Boot. Décrivez donc ici toutes mes étapes, j'espère que cela aide quelqu'un (solution de travail la plus simple, j'ai trouvé):

1. Générer une requête sertificate:

   • Générer une clé privée:

     openssl genrsa -des3 -passout pass:MY_PASSWORD -out user.key 2048

   • Générer une demande de certificat:

     openssl req -new -key user.key -out user.csr -passin pass:MY_PASSWORD

   Conserver user.key(et mot de passe) et envoyer la demande de certificat user.csrà la banque pour mon sertificate

2. Recevez 2 certificats: mon certificat racine client et mon certificat clientId.crtracine banque:bank.crt

3. Créer un magasin de clés Java (entrez le mot de passe de la clé et définissez le mot de passe du magasin de clés):

   openssl pkcs12 -export -in clientId.crt -inkey user.key -out keystore.p12 -name clientId -CAfile ca.crt -caname root

   Ne prêtez pas attention à la sortie: unable to write 'random state'. Java PKCS12 keystore.p12créé.

4. Ajouter dans le magasin de clés bank.crt(pour plus de simplicité, j'ai utilisé un magasin de clés):

   keytool -import -alias banktestca -file banktestca.crt -keystore keystore.p12 -storepass javaops

   Vérifiez les certificats de magasin de clés en:

   keytool -list -keystore keystore.p12

5. Prêt pour le code Java :) J'ai utilisé Spring Boot RestTemplateavec une org.apache.httpcomponents.httpcoredépendance supplémentaire :

   @Bean("sslRestTemplate")
   public RestTemplate sslRestTemplate() throws Exception {
     char[] storePassword = appProperties.getSslStorePassword().toCharArray();
     URL keyStore = new URL(appProperties.getSslStore());
   
     SSLContext sslContext = new SSLContextBuilder()
           .loadTrustMaterial(keyStore, storePassword)
     // use storePassword twice (with key password do not work)!!
           .loadKeyMaterial(keyStore, storePassword, storePassword) 
           .build();
   
     // Solve "Certificate doesn't match any of the subject alternative names"
     SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);
   
     CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(socketFactory).build();
     HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(client);
     RestTemplate restTemplate = new RestTemplate(factory);
     // restTemplate.setMessageConverters(List.of(new Jaxb2RootElementHttpMessageConverter()));
     return restTemplate;
   }

Étant donné un fichier p12 avec à la fois le certificat et la clé privée (généré par openssl, par exemple), le code suivant l'utilisera pour une HttpsURLConnection spécifique:

    KeyStore keyStore = KeyStore.getInstance("pkcs12");
    keyStore.load(new FileInputStream(keyStorePath), keystorePassword.toCharArray());
    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
    kmf.init(keyStore, keystorePassword.toCharArray());
    SSLContext ctx = SSLContext.getInstance("TLS");
    ctx.init(kmf.getKeyManagers(), null, null);
    SSLSocketFactory sslSocketFactory = ctx.getSocketFactory();

    HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
    connection.setSSLSocketFactory(sslSocketFactory);

L' SSLContextinitialisation prend un certain temps, vous pouvez donc le mettre en cache.

Je pense que le correctif était le type de magasin de clés, pkcs12 (pfx) a toujours une clé privée et le type JKS peut exister sans clé privée. Sauf si vous spécifiez dans votre code ou sélectionnez un certificat via un navigateur, le serveur n'a aucun moyen de savoir qu'il représente un client à l'autre bout.