Certificats clients Java via HTTPS / SSL

J'utilise Java 6 et j'essaie de créer un HttpsURLConnectioncontre un serveur distant, en utilisant un certificat client.
Le serveur utilise un certificat racine auto-signé et requiert la présentation d'un certificat client protégé par mot de passe. J'ai ajouté le certificat racine du serveur et le certificat client à un keystore java par défaut que j'ai trouvé dans /System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/lib/security/cacerts(OSX 10.5). Le nom du fichier keystore semble suggérer que le certificat client n'est pas censé y entrer?

Quoi qu'il en soit, l'ajout du certificat racine à ce magasin a résolu le tristement célèbre javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed' problem.

Cependant, je suis maintenant bloqué sur la façon d'utiliser le certificat client. J'ai essayé deux approches et aucune ne m'amène nulle part.
Tout d'abord, et de préférence, essayez:

SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
URL url = new URL("https://somehost.dk:3049");
HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
conn.setSSLSocketFactory(sslsocketfactory);
InputStream inputstream = conn.getInputStream();
// The last line fails, and gives:
// javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure

J'ai essayé de sauter la classe HttpsURLConnection (pas idéal car je veux parler HTTP avec le serveur), et faites ceci à la place:

SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
SSLSocket sslsocket = (SSLSocket) sslsocketfactory.createSocket("somehost.dk", 3049);
InputStream inputstream = sslsocket.getInputStream();
// do anything with the inputstream results in:
// java.net.SocketTimeoutException: Read timed out

Je ne suis même pas sûr que le certificat client soit le problème ici.

Enfin résolu;). Vous avez un indice fort ici (la réponse de Gandalfs en a également touché un peu). Les liens manquants étaient (principalement) le premier des paramètres ci-dessous, et dans une certaine mesure, j'ai négligé la différence entre les keystores et les truststores.

Le certificat de serveur auto-signé doit être importé dans un truststore:

keytool -import -alias gridserver -file gridserver.crt -storepass $ PASS -keystore gridserver.keystore

Ces propriétés doivent être définies (soit sur la ligne de commande, soit dans le code):

-Djavax.net.ssl.keyStoreType=pkcs12
-Djavax.net.ssl.trustStoreType=jks
-Djavax.net.ssl.keyStore=clientcertificate.p12
-Djavax.net.ssl.trustStore=gridserver.keystore
-Djavax.net.debug=ssl # very verbose debug
-Djavax.net.ssl.keyStorePassword=$PASS
-Djavax.net.ssl.trustStorePassword=$PASS

Exemple de code de travail:

SSLSocketFactory sslsocketfactory = (SSLSocketFactory) SSLSocketFactory.getDefault();
URL url = new URL("https://gridserver:3049/cgi-bin/ls.py");
HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
conn.setSSLSocketFactory(sslsocketfactory);
InputStream inputstream = conn.getInputStream();
InputStreamReader inputstreamreader = new InputStreamReader(inputstream);
BufferedReader bufferedreader = new BufferedReader(inputstreamreader);

String string = null;
while ((string = bufferedreader.readLine()) != null) {
    System.out.println("Received " + string);
}

Bien que cela ne soit pas recommandé, vous pouvez également désactiver complètement la validation des certificats SSL:

import javax.net.ssl.*;
import java.security.SecureRandom;
import java.security.cert.X509Certificate;

public class SSLTool {

  public static void disableCertificateValidation() {
    // Create a trust manager that does not validate certificate chains
    TrustManager[] trustAllCerts = new TrustManager[] { 
      new X509TrustManager() {
        public X509Certificate[] getAcceptedIssuers() { 
          return new X509Certificate[0]; 
        }
        public void checkClientTrusted(X509Certificate[] certs, String authType) {}
        public void checkServerTrusted(X509Certificate[] certs, String authType) {}
    }};

    // Ignore differences between given hostname and certificate hostname
    HostnameVerifier hv = new HostnameVerifier() {
      public boolean verify(String hostname, SSLSession session) { return true; }
    };

    // Install the all-trusting trust manager
    try {
      SSLContext sc = SSLContext.getInstance("SSL");
      sc.init(null, trustAllCerts, new SecureRandom());
      HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
      HttpsURLConnection.setDefaultHostnameVerifier(hv);
    } catch (Exception e) {}
  }
}

Avez-vous défini les propriétés du système KeyStore et / ou TrustStore?

java -Djavax.net.ssl.keyStore=pathToKeystore -Djavax.net.ssl.keyStorePassword=123456

ou avec le code

System.setProperty("javax.net.ssl.keyStore", pathToKeyStore);

Idem avec javax.net.ssl.trustStore

Si vous traitez avec un appel de service Web utilisant le framework Axis, il existe une réponse beaucoup plus simple. Si tout ce que vous voulez, c'est que votre client puisse appeler le service Web SSL et ignorer les erreurs de certificat SSL, inscrivez simplement cette déclaration avant d'appeler des services Web:

System.setProperty("axis.socketSecureFactory", "org.apache.axis.components.net.SunFakeTrustSocketFactory");

Les clauses de non-responsabilité habituelles selon lesquelles il s'agit d'une très mauvaise chose à faire dans un environnement de production s'appliquent.

J'ai trouvé ceci sur le wiki d'Axis .

Pour moi, c'est ce qui a fonctionné avec Apache HttpComponents ~ HttpClient 4.x:

    KeyStore keyStore  = KeyStore.getInstance("PKCS12");
    FileInputStream instream = new FileInputStream(new File("client-p12-keystore.p12"));
    try {
        keyStore.load(instream, "helloworld".toCharArray());
    } finally {
        instream.close();
    }

    // Trust own CA and all self-signed certs
    SSLContext sslcontext = SSLContexts.custom()
        .loadKeyMaterial(keyStore, "helloworld".toCharArray())
        //.loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()) //custom trust store
        .build();
    // Allow TLSv1 protocol only
    SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
        sslcontext,
        new String[] { "TLSv1" },
        null,
        SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); //TODO
    CloseableHttpClient httpclient = HttpClients.custom()
        .setHostnameVerifier(SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER) //TODO
        .setSSLSocketFactory(sslsf)
        .build();
    try {

        HttpGet httpget = new HttpGet("https://localhost:8443/secure/index");

        System.out.println("executing request" + httpget.getRequestLine());

        CloseableHttpResponse response = httpclient.execute(httpget);
        try {
            HttpEntity entity = response.getEntity();

            System.out.println("----------------------------------------");
            System.out.println(response.getStatusLine());
            if (entity != null) {
                System.out.println("Response content length: " + entity.getContentLength());
            }
            EntityUtils.consume(entity);
        } finally {
            response.close();
        }
    } finally {
        httpclient.close();
    }

Le fichier P12 contient le certificat client et la clé privée client, créés avec BouncyCastle:

public static byte[] convertPEMToPKCS12(final String keyFile, final String cerFile,
    final String password)
    throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException,
    NoSuchProviderException
{
    // Get the private key
    FileReader reader = new FileReader(keyFile);

    PEMParser pem = new PEMParser(reader);
    PEMKeyPair pemKeyPair = ((PEMKeyPair)pem.readObject());
    JcaPEMKeyConverter jcaPEMKeyConverter = new JcaPEMKeyConverter().setProvider("BC");
    KeyPair keyPair = jcaPEMKeyConverter.getKeyPair(pemKeyPair);

    PrivateKey key = keyPair.getPrivate();

    pem.close();
    reader.close();

    // Get the certificate
    reader = new FileReader(cerFile);
    pem = new PEMParser(reader);

    X509CertificateHolder certHolder = (X509CertificateHolder) pem.readObject();
    java.security.cert.Certificate x509Certificate =
        new JcaX509CertificateConverter().setProvider("BC")
            .getCertificate(certHolder);

    pem.close();
    reader.close();

    // Put them into a PKCS12 keystore and write it to a byte[]
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    KeyStore ks = KeyStore.getInstance("PKCS12", "BC");
    ks.load(null);
    ks.setKeyEntry("key-alias", (Key) key, password.toCharArray(),
        new java.security.cert.Certificate[]{x509Certificate});
    ks.store(bos, password.toCharArray());
    bos.close();
    return bos.toByteArray();
}

J'utilise le package Apache commons HTTP Client pour faire cela dans mon projet actuel et cela fonctionne bien avec SSL et un certificat auto-signé (après l'avoir installé dans des cacerts comme vous l'avez mentionné). Jetez-y un œil ici:

http://hc.apache.org/httpclient-3.x/tutorial.html

http://hc.apache.org/httpclient-3.x/sslguide.html

Je pense que vous avez un problème avec votre certificat de serveur, ce n'est pas un certificat valide (je pense que c'est ce que signifie «handshake_failure» dans ce cas):

Importez votre certificat de serveur dans votre keystore trustcacerts sur le JRE du client. Cela se fait facilement avec keytool :

keytool
    -import
    -alias <provide_an_alias>
    -file <certificate_file>
    -keystore <your_path_to_jre>/lib/security/cacerts

Utilisation du code ci-dessous

-Djavax.net.ssl.keyStoreType=pkcs12

ou

System.setProperty("javax.net.ssl.keyStore", pathToKeyStore);

n'est pas du tout nécessaire. Il n'est pas non plus nécessaire de créer votre propre usine SSL personnalisée.

J'ai également rencontré le même problème, dans mon cas, il y avait un problème qui complète la chaîne de certificats n'était pas importée dans les magasins de confiance. Importez des certificats à l'aide de l'utilitaire keytool à droite du certificat racine, vous pouvez également ouvrir le fichier cacerts dans le bloc-notes et voir si la chaîne de certificats complète est importée ou non. Vérifiez le nom d'alias que vous avez fourni lors de l'importation de certificats, ouvrez les certificats et voyez combien il en contient, le même nombre de certificats devrait être présent dans le fichier cacerts.

Le fichier cacerts doit également être configuré sur le serveur sur lequel vous exécutez votre application, les deux serveurs s'authentifieront mutuellement avec des clés publiques / privées.