1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
| package server;
import java.io.IOException;
import java.io.InputStream;
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 javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLServerSocket;
import javax.net.ssl.SSLServerSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509KeyManager;
import javax.net.ssl.X509TrustManager;
public class ServerUtils {
/**
* Ca c'est une fonction utilitaire permettant de récupérer le "vérifieur de certificat", on prend uniquement celui correspondant au certificat pour minimiser le temps de chargement à la connexion
*
* Pas très intéressante...
*/
private static X509TrustManager tm(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException {
TrustManagerFactory trustMgrFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
trustMgrFactory.init(keystore);
//on prend tous les managers
TrustManager trustManagers[] = trustMgrFactory.getTrustManagers();
for (int i = 0; i < trustManagers.length; i++) {
if (trustManagers[i] instanceof X509TrustManager) {
//on renvoie juste celui que l'on va utiliser
return (X509TrustManager) trustManagers[i];
}
}
return null;
};
/**
* Ca c'est une fonction utilitaire permettant de récupérer le "gestionnaire de mot de passes des clés" (en gros)
*
* Pas très intéressante...
*/
private static X509KeyManager km(KeyStore keystore, String password) throws NoSuchAlgorithmException, KeyStoreException, UnrecoverableKeyException {
KeyManagerFactory keyMgrFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyMgrFactory.init(keystore, password.toCharArray());
//on prend tous les managers
KeyManager keyManagers[] = keyMgrFactory.getKeyManagers();
for (int i = 0; i < keyManagers.length; i++) {
if (keyManagers[i] instanceof X509KeyManager) {
//on renvoie juste celui que l'on va utiliser
return (X509KeyManager) keyManagers[i];
}
}
return null;
};
/**
* Le vrai morceau, que l'on utilisera
*/
public static SSLServerSocket getServerSocketWithCert(int port, InputStream pathToCert, String passwordFromCert) throws IOException,
KeyManagementException, NoSuchAlgorithmException, CertificateException, KeyStoreException, UnrecoverableKeyException{
TrustManager[] tmm = new TrustManager[1];
KeyManager[] kmm = new KeyManager[1];
//On charge le lecteur de Keystore en fonction du format
//ATTENTION
//POUR LES SERVEURS android, remplacez le JKS par BKS, si c'est juste le client qui est android, laissez JKS
KeyStore ks = KeyStore.getInstance("JKS");
//On charge le Keystore avec sont stream et son mot de passe
ks.load(pathToCert, passwordFromCert.toCharArray());
//On lance les gestionnaires de clés et de vérification des clients
tmm[0]=tm(ks);
kmm[0]=km(ks, passwordFromCert);
//On démarre le contexte, autrement dit le langage utilisé pour crypter les données
//ATTENTION
//Ici, on peut remplacer SSL par TLSv1.2 , mais il faudra le faire aussi bien dans le client que le serveur
SSLContext ctx = SSLContext.getInstance("TLSv1.2");
ctx.init(kmm, tmm, null);
//On lance la serversocket sur le port indiqué, avec le contexte fourni
SSLServerSocketFactory socketFactory = (SSLServerSocketFactory) ctx.getServerSocketFactory();
return (SSLServerSocket) socketFactory.createServerSocket(port);
}
} |
