[HTTPS] connexion à un site + acceptation du certificat

Ci-joint un code que je viens de terminer après qqes jours de dur labeur...

Précision : mon appel récupére un flux XML sauvegardé dans un fichier pour traitement ultérieur. L'url accédée nécessite une authentification gérée par l'objet Authenticator.

Pour le certificat, ce dernier est stocké dans un répertoire du serveur et chargé dynamiquement à chaque appel.
Une 2nde solution est de l'importer dans le système (websphere pour ma part) mais l'opération n'a pas fonctionné.

J'ai cependant un pblm en cours d'investigation : le 1er appel après un arrêt-relance websphere ne fonctionne pas. L'exception "unknown certificate" m'est restituée.

Bon courage

Laurent
Code:
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
            URL url=null;
        	//javax.net.ssl.HttpsURLConnection httpsURLConnection=null;
        	//com.sun.net.ssl.HttpsURLConnection httpsURLConnection=null;
        	HttpsURLConnection httpsURLConnection=null;
        	InputStream stream=null;
        	BufferedReader buffer=null;
 
        	// Tableau de chaine servant à stocker le flux
        	List fluxRecu=new Vector();
 
        	String nomFichier=null;
        	//String repertoire = request.getRealPath("/jsp/nsm/tempfiles/");
 
 
        	String nomFichierCertificat = request.getRealPath("/jsp/nsm/certificats/") +Proprietes.getValeur("EdgeCertificat");
        	//String nomFichierCertificat = request.getRealPath("/jsp/nsm/certificats/") +"certpasbon.cer";
 
        	// Authentification
        	String username = Proprietes.getValeur("EdgeUsername");
            String password = Proprietes.getValeur("EdgePassword");
            Logger.debug("EdgeUsername="+username);
            Logger.debug("EdgePassword="+password);
 
 
 
 
 
        	// Trace
        	long start = new Date().getTime();
 
 
 
        	try {
        		Logger.debug("===>EdgeConnection - début d'exécution à "+start);
            	//
        		// Connexion
        		//
    		    // Objet pour l'authentification
        		//
    		    Authenticator.setDefault(new MyAuthenticator(username, password));
 
        		//
        		// HttpsURLConnection
        		//
        		//url = new URL("http://62.8.104.53:8080/ClientProfiling/accountProfile.xml?aid="+idTitulaire);
        		url = new URL(hostName);
        		Logger.debug("url="+url.toString());
 
            	httpsURLConnection = (HttpsURLConnection) url.openConnection();
            	httpsURLConnection.setRequestMethod("GET");
            	httpsURLConnection.setDoInput(true);
            	httpsURLConnection.setDoOutput(true);
 
 
            	//
            	// Create Certificate
        		Logger.debug("Create certificat...");
        		Logger.debug("nomFichierCertificat="+nomFichierCertificat);
 
        		File f = new File(nomFichierCertificat);
            	if (f.exists()) {
            		Logger.debug("le fichier certificat Edge existe");
            	}
            	else {
            		Logger.erreur("Erreur : le fichier certificat Edge n'existe pas");
            		return;
            	}
 
 
            	X509Certificate cert=null;
            	try {
        			 InputStream inStrm = new FileInputStream(nomFichierCertificat);
                	 CertificateFactory cf = CertificateFactory.getInstance("X.509");
                	 cert = (X509Certificate)cf.generateCertificate(inStrm);
                	 inStrm.close();
    			} catch (Exception e) {
    				// TODO: handle exception
    				Logger.debug("Erreur de chargement du certificat");
            		Logger.debug("Message d'erreur="+e.getMessage());
            		e.printStackTrace();
            		return;
    			}
 
 
    			// Create KeyStore
        		Logger.debug("Create keystore...");
    			KeyStore ks=null;
    			try {
    				ks = KeyStore.getInstance("PKCS12");
    	    		ks.load(null, null);
    				ks.setCertificateEntry("edge", cert);
    	    		Logger.debug("keystore.size après="+ks.size());
    			} catch (Exception e) {
    				// TODO: handle exception
    	        	Logger.erreur("Erreur d'init. du keystore");
            		Logger.erreur("Message d'erreur="+e.getMessage());
            		e.printStackTrace();
            		return;
    			}
 
 
    			// Create TrustManagerFactory
        		Logger.debug("Create TrustManagerFactory...");
    			TrustManagerFactory tmf=null;
    			try {
    				//tmf = TrustManagerFactory.getInstance((Security.getProperty("ssl.TrustManagerFactory.algorithm")==null?"SunX509":Security.getProperty("ssl.TrustManagerFactory.algorithm"))); 
    				tmf = TrustManagerFactory.getInstance((Security.getProperty("ssl.TrustManagerFactory.algorithm")==null?"IbmX509":Security.getProperty("ssl.TrustManagerFactory.algorithm")));
    				tmf.init(ks);
    				Logger.debug("Done");
    			} catch (Exception e) {
            		Logger.erreur("Erreur de création du TrustManagerFactory");
            		Logger.erreur("Message d'erreur="+e.getMessage());
            		e.printStackTrace();
            		return;
    			}
 
 
 
    			// Initialize SSLContext
        		Logger.debug("Initialize SSLContext...");
        		try {
    		        TrustManager[] tab = tmf.getTrustManagers();
    		    	SSLContext sslContext = SSLContext.getInstance("SSL");
    		        //sc.init(null, trustMgrs, new java.security.SecureRandom());
    		        sslContext.init(null, tab, new java.security.SecureRandom());
    		        httpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
    		        Logger.debug("SSL parameters done...");
    		    } catch (Exception e) {
    				// TODO: handle exception
    	        	Logger.erreur("Erreur d'init. du SSLContext");
            		Logger.erreur("Message d'erreur="+e.getMessage());
            		e.printStackTrace();
            		return;
    		    }
 
 
 
    			//
    		    //Connexion à l'URL
    		    //
            	Logger.debug("Avant connexion");
            	httpsURLConnection.connect();
            	Logger.debug("Après connexion");
 
            	Logger.debug ("ResponseCode après connexion="+httpsURLConnection.getResponseCode());
 
 
            	//
            	// Demande d'envoi du flux au site distant
            	//
            	Logger.debug("Avant getInputStream");
            	stream = httpsURLConnection.getInputStream();
            	//stream = (InputStream) url.getContent();
            	Logger.debug("Après getInputStream");
 
            	Logger.debug("ResponseCode="+httpsURLConnection.getResponseCode());
 
            	if (httpsURLConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                	Logger.debug("Le site distant est ok pour nous envoyer le flux");
                	buffer = new BufferedReader (new InputStreamReader(stream));
                	String inputLine;
                	while ((inputLine = buffer.readLine()) != null) {
                		// Stockage du flux dans une liste
                		//Logger.debug(inputLine);
                		fluxRecu.add(inputLine);
                	}
                	buffer.close();
                	httpsURLConnection.disconnect();
                	Logger.debug("Déconnexion du site "+url.toString());
                	Logger.debug("Nombre de lignes reçues = " + (fluxRecu.size()+1));
 
 
                	// Sauvegarde du flux reçu dans un fichier
                	nomFichier = Outils.sauvegarderFluxDansFichier (request, fluxRecu, appel, idTitulaire);
                	this.setAccessResultOK(true);
                	this.setNomFichier(nomFichier);
            	}
            	else {
                	Logger.erreur("Connexion ko");
            		Logger.erreur("Erreur="+httpsURLConnection.getResponseMessage());
            		return;
            	}
 
 
        	}
        	catch (MalformedURLException e) {
       			Logger.erreur("Problème MalformedURLException avec l'URL : " + url.toString());
           		Logger.erreur("Message d'erreur="+e.getMessage());
        		e.printStackTrace();
        		return;
        	}
        	catch (IOException e) {
           		Logger.erreur("Problème IOException avec l'URL : " + url.toString());
           		Logger.erreur("Message d'erreur="+e.getMessage());
       			e.printStackTrace();
       			return;
        	}
 
        	finally {
        		if (stream!=null) {
        			try {
        				//stream.close();
        				buffer.close();
 
        			}
        			catch (Exception e) {
        	    		Logger.erreur("Message d'erreur="+ e.getMessage());
        	    		e.printStackTrace();
        			}
     			}
        	}
 
 
        	Logger.debug("===>EdgeConnection - sortie - temps d'appel = : "+ (new Date().getTime() - start));