Apache HttpClient 4.3 et x509 certificat du client pour authentifier

Tomas, c'est peut-être trop tard, mais j'espère que ça va aider les autres...
Il y a la méthode que j'utilise pour créer CloseableHttpClient à l'aide d'Apache HttpClient 4.3:

public static CloseableHttpClient prepareClient() {
    try {           
        SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).useTLS().build();
        HttpClientBuilder builder = HttpClientBuilder.create();
        SSLConnectionSocketFactory sslConnectionFactory = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
        builder.setSSLSocketFactory(sslConnectionFactory);
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory>create()
                .register("https", sslConnectionFactory)
                .register("http", new PlainConnectionSocketFactory())
                .build();
        HttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(registry);
        builder.setConnectionManager(ccm);
        return builder.build();
    } catch (Exception ex) {

        return null;
    }
}

Fondation Apache déplacé org.apache.http.conn.le protocole ssl.SSLContextBuilder, org.apache.http.conn.le protocole ssl.SSLContexts et org.apache.http.conn.le protocole ssl.SSLSocketFactory à déconseillé de commencer avec la version 4.4, Il y vous pouvez trouver Apache Client 4.5.2 API Depracated Liste. Donc, perméable à la méthode peut être modifié comme ceci:

public static CloseableHttpClient prepareClient() {
    try {
        SSLContext sslContext = SSLContexts.custom()
                .loadTrustMaterial(null, new TrustSelfSignedStrategy()).build();
        HttpClientBuilder builder = HttpClientBuilder.create();
        SSLConnectionSocketFactory sslConnectionFactory = 
                new SSLConnectionSocketFactory(sslContext.getSocketFactory(), 
                        new NoopHostnameVerifier());
        builder.setSSLSocketFactory(sslConnectionFactory);
        Registry<ConnectionSocketFactory> registry = 
                RegistryBuilder.<ConnectionSocketFactory>create()
                .register("https", sslConnectionFactory)
                .register("http", new PlainConnectionSocketFactory())
                .build();
        HttpClientConnectionManager ccm = new BasicHttpClientConnectionManager(registry);
        builder.setConnectionManager(ccm);
        return builder.build();
    } catch (Exception ex) {
        LOG.error("couldn't create httpClient!! {}", ex.getMessage(), ex);
        return null;
    }
}

NoopHostnameVerifier

La NO_OP HostnameVerifier s'avère essentiel vérification du nom d'hôte
off. Cette mise en œuvre est un no-op, et de ne jamais jette l'
SSLException.

Si vous avez besoin de vérifier le nom d'hôte, vous pouvez utiliser DefaultHostnameVerifier ou vous pouvez mettre en œuvre votre nom d'hôte personnalisé verifier.

OriginalL'auteur Daniyar

Vous devez créer un fichier de clés que contient la confiance des CAs c'est à dire trust.jks. Dans ce magasin de clés, vous devez les mettre uniquement le certificat du serveur que l'application va se connecter.

Ensuite, vous avez besoin d'un fichier de clés pour l'identité du serveur c'est à dire identity.jks. Dans ce magasin de clés, vous devez les stocker mettre la clé privée + certificat + autorité de certification de la chaîne de sous un alias (un nom) que votre application va utiliser pour s'authentifier auprès du serveur.

Alors vous pourriez construire la HttpClient comme ceci:

public static HttpClient getHttpClient() throws KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException, UnrecoverableKeyException, KeyManagementException {
KeyStore identityKeyStore = KeyStore.getInstance("jks");
identityKeyStore.load(MyClass.class.getClassLoader().getResourceAsStream("identity.jks"), "identity_password".toCharArray());
KeyStore trustKeyStore = KeyStore.getInstance("jks");
trustKeyStore.load(MyClass.class.getClassLoader().getResourceAsStream("trust.jks"), "trust_password".toCharArray());
SSLContext sslContext = SSLContexts
.custom()
//load identity keystore
.loadKeyMaterial(identityKeyStore, "identity_password".toCharArray(), new PrivateKeyStrategy() {
@Override
public String chooseAlias(Map<String, PrivateKeyDetails> aliases, Socket socket) {
return "identity_alias";
}
})
//load trust keystore
.loadTrustMaterial(trustKeyStore, null)
.build();
SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext,
new String[]{"TLSv1.2", "TLSv1.1"},
null,
SSLConnectionSocketFactory.getDefaultHostnameVerifier());
return HttpClients.custom()
.setSSLSocketFactory(sslConnectionSocketFactory)
.build();
}

Pour construire le identity.jks, vous devez le CAs de la chaîne, la clé publique et la clé privée:

$1 = mycustomidentity
# make the keycert bundle for pkcs12 keystore
cat intermediate/certs/ca-chain.cert.pem \
intermediate/certs/$1.cert.pem \
intermediate/private/$1.key.pem \
> intermediate/keycerts/$1.full-chain.keycert.pem
# generate the pkcs12 keystore with the alias of the server url
openssl pkcs12 -export \
-in intermediate/keycerts/$1.full-chain.keycert.pem \
-out intermediate/pkcs12s/$1.full-chain.p12 \
-name $1 \
-noiter -nomaciter
# .p12 to .jks
keytool -importkeystore -srckeystore $1.full-chain.p12 \
-srcstoretype pkcs12 -srcalias $1 \
-destkeystore identity.jks -deststoretype jks \
-deststorepass identity_password -destalias identity_alias

Pour la trust.jks fichier que vous avez seulement besoin du certificat du serveur (voir https://stackoverflow.com/a/36427118/2692914 ou https://stackoverflow.com/a/7886248/2692914), il n'y a pas de problème à changer l'alias:

# .crt, .cer into a .jks
keytool -import -alias trust_alias -file server_certificate.crt \
-keystore trust.jks

OriginalL'auteur lmiguelmh