Java: Chargement du fichier de clés SSL via une ressource

J'ai dû faire quelque chose de similaire a tout à l'arrière. J'ai eu un fichier de certificat et j'ai dû trouver un moyen de le charger et l'utiliser pour une connexion SSL. Espérons que ce que j'ai fait va vous aider.

D'abord, j'ai dû créer un trust manager:

public class MyX509TrustManager implements X509TrustManager {

    X509TrustManager pkixTrustManager;

    MyX509TrustManager() throws Exception {

        String certFile = "/certificates/MyCertFile.cer";

        Certificate myCert = CertificateFactory.getInstance("X509").generateCertificate(this.getClass().getResourceAsStream(valicertFile));

        KeyStore keyStore = KeyStore.getInstance("JKS");
        keyStore.load(null, "".toCharArray());
        keyStore.setCertificateEntry("myCert", myCert);

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("PKIX");
        trustManagerFactory.init(keyStore);

        TrustManager trustManagers[] = trustManagerFactory.getTrustManagers();

        for(TrustManager trustManager : trustManagers) {
            if(trustManager instanceof X509TrustManager) {
                pkixTrustManager = (X509TrustManager) trustManager;
                return;
            }
        }

        throw new Exception("Couldn't initialize");
    }

    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        pkixTrustManager.checkServerTrusted(chain, authType);
    }

    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        pkixTrustManager.checkServerTrusted(chain, authType);
    }

    public X509Certificate[] getAcceptedIssuers() {
        return pkixTrustManager.getAcceptedIssuers();
    }
}

Après que j'ai eu à créer un socket usine qui a utilisé ma confiance manager:

public class MySSLProtocolSocketFactory implements SecureProtocolSocketFactory {
private SSLContext sslContext = null;
public MySSLProtocolSocketFactory() {
super();
}
private static SSLContext createMySSLContext() {
try {
MyX509TrustManager myX509TrustManager = new MyX509TrustManager();
SSLContext context = SSLContext.getInstance("TLS");
context.init(null, new MyX509TrustManager[] { myX509TrustManager}, null);
return context;
}
catch(Exception e) {
Log.error(Log.Context.Net, e);
return null;
}
}
private SSLContext getSSLContext() {
if(this.sslContext == null) {
this.sslContext = createMySSLContext();
}
return this.sslContext;
}
public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException {
return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
}
public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort, final HttpConnectionParams params) throws IOException {
if(params == null) {
throw new IllegalArgumentException("Parameters may not be null");
}
int timeout = params.getConnectionTimeout();
SocketFactory socketFactory = getSSLContext().getSocketFactory();
if(timeout == 0) {
return socketFactory.createSocket(host, port, localAddress, localPort);
}
else {
Socket socket = socketFactory.createSocket();
SocketAddress localAddr = new InetSocketAddress(localAddress, localPort);
SocketAddress remoteAddr = new InetSocketAddress(host, port);
socket.bind(localAddr);
socket.connect(remoteAddr, timeout);
return socket;
}
}
public Socket createSocket(String host, int port) throws IOException {
return getSSLContext().getSocketFactory().createSocket(host, port);
}
public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
}
public boolean equals(Object obj) {
return ((obj != null) && obj.getClass().equals(MySSLProtocolSocketFactory.class));
}
public int hashCode() {
return MySSLProtocolSocketFactory.class.hashCode();
}
}

Ensuite, j'ai utilisé de cette prise en usine pour envoyer mon POST:

Protocol.registerProtocol("myhttps", new Protocol("myhttps", new MySSLProtocolSocketFactory(), 443));
PostMethod postMethod = new PostMethod("myhttps://some.url.here");
HttpClient client = new HttpClient();
int status = client.executeMethod(postMethod);

La seule chose que je ne pouvais pas comprendre comment il suffit d'ajouter le fichier de certificat à l'ordinaire de magasin de clés. Tous les exemples de code source, j'ai trouvé lors de mes recherches, a souligné la création d'un socket facteur, puis l'enregistrement d'un protocole avec ce socket usine. Il est peut-être une façon d'utiliser le socket usine à établir une connexion sans enregistrement d'un protocole; je n'ai pas étudier à fond. Dans mon cas en particulier, la création d'un protocole spécifique a été nécessaire. J'espère que cela va obtenir votre plus loin le long de la voie. J'avoue que cela semble un peu rond-point; j'ai ressenti la même chose quand je l'ai fait au départ. Mais c'était la seule façon que je l'ai eu à travailler. Peut-être que d'autres personnes ont une meilleure solution.

OriginalL'auteur Vivin Paliath

Avec l'Axe, je pense que vous devez configurer son SSLSocketFactory via:

AxisProperties.setProperty("axis.socketSecureFactory",
"com.example.MySSLSocketFactory");

où com.example.MySSLSocketFactory est votre classe qui implémente org.apache.axis.components.net.SecureSocketFactory (vous pouvez étendre org.apache.axis.components.net.JSSESocketFactory peut-être).

Dans le create méthode, créer un socket à l'aide de la douille de l'usine obtenu à partir de la SSLContext vous avez configuré.

OriginalL'auteur Bruno