Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 18 sur 18
  1. #1
    Candidat au titre de Membre du Club
    Inscrit en
    janvier 2005
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : janvier 2005
    Messages : 74
    Points : 14
    Points
    14

    Par défaut Connexion Java Client au Serveur HTTPS via proxy

    Je suis entrain de developper un client java qui se connecte a une servlet (web service) en HTTPS / SSL , mon application passe par le proxy.

    Voilà le code :
    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
     
     
    package sslproject;
     
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.MalformedURLException;
    import java.net.URL;
    import javax.net.ssl.*;
    import java.security.KeyManagementException;
    import java.security.NoSuchAlgorithmException;
     
     
     
    public class HtpsConnection {
    	public static String urlHost ="https://X.X.X.X:443/PathServle";
     
    	public static void main (String[] args) throws IOException {
    		System.out.println(getPage(urlHost).toString());
    	}
     
    	public static StringBuffer getPage(String urlString)
    	{
       	public static String  proxyPwd = "proxyPWD";
    	public static String proxyUser = "proxyUSER";
    	public static String proxyHost = "proxyIP";
    	public static int    proxyPort = port_proxy;
     
            System.getProperties().put("javax.net.debug", "ssl" );
    	System.getProperties().put("https.proxySet", "true");
            System.getProperties().put("https.proxyHost", proxyHost);
            System.getProperties().put("https.proxyPort", proxyPort);
     
     
            TrustManager[] trustAllCerts = new TrustManager[]{
    			new X509TrustManager() {
    			public boolean checkClientTrusted(java.security.cert.X509Certificate[] chain){
    			return true;
    			}
    			public boolean isServerTrusted(java.security.cert.X509Certificate[] chain){
    			return true;
    			}
    			public boolean isClientTrusted(java.security.cert.X509Certificate[] chain){
    			return true;
    			}
    			public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    			return null;
    			}
    			public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
    			public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
    			}
     
    		};
     
            try
            {
    	        SSLContext sc = SSLContext.getInstance("SSL");
    	        sc.init(null, trustAllCerts, null);
    	        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
            }
            catch(NoSuchAlgorithmException nsae)
            {}
            catch(KeyManagementException kme)
            {
            	kme.printStackTrace();
            }
     
            try
    		{
    			HttpsURLConnection connec = null;
    			URL url = new URL(urlString);
    			connec = (HttpsURLConnection)url.openConnection();
    			connec.setDoInput(true);
                connec.setUseCaches(false);
     
                String authentication = proxyUser + ":" + proxyPwd;
                String encodedPassword = "Basic " + new sun.misc.BASE64Encoder().encode(authentication.getBytes());
                connec.setRequestProperty("Proxy-Authorization", encodedPassword);
                //connec.setRequestProperty("X-TestHeader", "value");
     
                connec.setRequestMethod("POST");
                connec.setDoOutput(true);
     
                String msg;
     
                msg= "---"+"\r\n";
     
                int statusCode = connec.getResponseCode();
     
                //System.err.println("Certificats  --->"+connec.getServerCertificates());
                System.err.println("HEADER --->"+connec.getHeaderFields());
     
                StringBuffer pageContents = new StringBuffer();
                if(statusCode==HttpsURLConnection.HTTP_OK)
                {
    				System.err.println("Connected ...!");
     
    				BufferedReader in = new BufferedReader(new InputStreamReader(connec.getInputStream()));
     
    				PrintWriter out = new PrintWriter(connec.getOutputStream(), true );
                	out.println(msg);
     
    				String curLine = in.readLine();
    				 while(curLine!=null)
    				 {
    					pageContents.append(curLine);
    					curLine = in.readLine();
    				 }
                }
                return pageContents;
    		}
    		catch(MalformedURLException mue)
    		{
    			mue.printStackTrace();
    		}
    		catch(IOException ioe)
    		{
    			ioe.printStackTrace();
    		}
     
    		return null;
    	}
    }
    Voilà la réponse :
    HEADER --->{null=[HTTP/1.1 500 Internal Server Error], Content-Length=[101], Connection=[Close], Date=[Fri, 01 Dec 2006 11:38:11 GMT], Content-Type=[text/html]}
    Sou unix/linx j'ai executer la command wget voilà le résultat :
    root@becane:~#wget X.X.X.X 443
    ...
    Connecting to X.X.X.X:443... connected.
    ERROR: Certificate verification error for X.X.X.X : unable to get local issuer certificate
    ERROR: certificate common name `X.X.X.X' doesn't match requested host name `X.X.X.X:443'.
    To connect to X.X.X.X:443 insecurely, use `--no-check-certificate'.
    Unable to establish SSL connection.

    --17:19:09-- http://443/
    => `index.html.1'
    Resolving 443... 0.0.1.187
    Connecting to 443|0.0.1.187|:80... failed: Invalid argument.
    FINISHED --17:19:09--
    Downloaded: 0 bytes in 0 files
    Apparament j'ai un problème de certificat !

    Comment utiliser le certificat du serveur https dans le code client java ?
    Et comment fait on pour l'obtenir ?

    Est ce que quelqu'un peut m'expliquer comment résoudre le problème est établir une connexion https ?

    Des exemples de code sa serai sympa.

    Merci d'avance

  2. #2
    Modérateur

    Inscrit en
    août 2006
    Messages
    3 099
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 3 099
    Points : 3 795
    Points
    3 795

    Par défaut

    Il faut setter deux propriétés système comme cela:

    Code :
    1
    2
    3
     
    System.setPropert("javax.net.ssl.trustStore", "tonFichierCertificat.ks");
    System.setProperty("javax.net.ssl.trustStorePassword", "tonMotDePasse");
    Ensuite tu appelles ton service web normalement.

  3. #3
    Candidat au titre de Membre du Club
    Inscrit en
    janvier 2005
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : janvier 2005
    Messages : 74
    Points : 14
    Points
    14

    Par défaut

    Citation Envoyé par fr1man
    Il faut setter deux propriétés système comme cela:

    Code :
    1
    2
    3
     
    System.setPropert("javax.net.ssl.trustStore", "tonFichierCertificat.ks");
    System.setProperty("javax.net.ssl.trustStorePassword", "tonMotDePasse");
    Ensuite tu appelles ton service web normalement.
    Comment fait on pour avoir le fichier "tonFichierCertificat.ks" ?

    Merci pour ton aide

  4. #4
    Modérateur

    Inscrit en
    août 2006
    Messages
    3 099
    Détails du profil
    Informations forums :
    Inscription : août 2006
    Messages : 3 099
    Points : 3 795
    Points
    3 795

    Par défaut

    Je ne vais pas pouvoir t'aider plus que ça, car je n'y connais pas grand chose.
    Ce que je peux dire, c'est que quand tu fais des connexions https, il te faut un certificat. Ce certificat peut être généré par les outils fournis avec le jdk, keytool. Si tu veux un vrai certificat, il faut faire appel à une boite qui t'en créera un.
    Voilà en gros ce que je sais. J'espère que je n'ai pas dit trop de bêtises.
    Bon courage.

  5. #5
    Candidat au titre de Membre du Club
    Inscrit en
    janvier 2005
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : janvier 2005
    Messages : 74
    Points : 14
    Points
    14

    Par défaut

    Citation Envoyé par fr1man
    Je ne vais pas pouvoir t'aider plus que ça, car je n'y connais pas grand chose.
    Ce que je peux dire, c'est que quand tu fais des connexions https, il te faut un certificat. Ce certificat peut être généré par les outils fournis avec le jdk, keytool. Si tu veux un vrai certificat, il faut faire appel à une boite qui t'en créera un.
    Voilà en gros ce que je sais. J'espère que je n'ai pas dit trop de bêtises.
    Bon courage.
    si j'ai bien compris alors je dois creer mon propre certificats et faire la connexion au serveur HTTPS ? alors je n'ai pas besoin du certificats du serveur HTTPS ?

    Merci encore

  6. #6
    Membre du Club
    Inscrit en
    novembre 2006
    Messages
    85
    Détails du profil
    Informations forums :
    Inscription : novembre 2006
    Messages : 85
    Points : 68
    Points
    68

    Par défaut Java WS HTTPS

    Je dois également me connecter a un WebService en HTTPS (sans proxy),
    si j'ai compris le principe, le serveur auquel tu veux accèder doit te filer un certificat SSL (X509) et une clef.

    Ensuite tu le convertis en PKCS12 (.p12)
    Code :
    openssl pkcs12 -export -certfile serveurDistant-cert.pem -inkey user.key -out client.p12
    Et tu le convertis enfin en JKS
    Code :
    java org/mortbay/jetty/security/PKCS12import $DST/client.p12 $DST/client.jks
    ( ou avec l'excelent outil KeyTool IUI http://ragingcat.developpez.com/java/outils/keytool/ui/ )

    Verifier le contenu de ton JKS
    Code :
    1
    2
    keytool -list -v -keystore client.jks
    Votre Keystore contient 1 entrée(s)
    Ensuite java accepte le format PKCS12 ou en natif le JKS
    Donc tu ajoute a ton keystore, le certificat que tu annonces comme sûr.

    Code :
    1
    2
    3
    4
          System.setProperty("javax.net.ssl.trustStore", "client.jks");
          System.setProperty("javax.net.ssl.trustStoreType", "jks");
          //System.setProperty("javax.net.ssl.trustStoreType", "pkcs12");
          System.setProperty("javax.net.ssl.trustStorePassword", "motDePasse");
    Voilà, j'en suis là, mais bloqué par l'exception :
    Exception in thread "main" javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
    En comptant sur ceux qui ont réussis pour nous expliquer la suite....

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    /*
     Setting properties
     
    The following properties must be set at start of maven to be accessible when HttpClient starts up.
     
    javax.net.ssl.trustStore
        the path to the keystore where trusted certificates are stored
    javax.net.ssl.trustStoreType
        the type of storage for this store, maybe either jks (default) or pkcs12
    javax.net.ssl.trustStorePassword
        the password protecting the store
    javax.net.ssl.keyStore
        the path to the keystore where user's private key is stored
    javax.net.ssl.keyStoreType
        the type of storage for this store, maybe either jks (default) or pkcs12
    javax.net.ssl.keyStorePassword
        the password protecting the store
     */

  7. #7
    Candidat au titre de Membre du Club
    Inscrit en
    janvier 2005
    Messages
    74
    Détails du profil
    Informations forums :
    Inscription : janvier 2005
    Messages : 74
    Points : 14
    Points
    14

    Par défaut

    Est ce que quelqu'un peut nous aider ..!

  8. #8
    Candidat au titre de Membre du Club
    Inscrit en
    octobre 2004
    Messages
    68
    Détails du profil
    Informations forums :
    Inscription : octobre 2004
    Messages : 68
    Points : 11
    Points
    11

    Par défaut

    Je remonte ce topic car je rencontre exactement le même problème.

    Si quelqu'un a la solution, je suis preneur !

    Merci à tous

  9. #9
    Membre habitué Avatar de ludosoft
    Homme Profil pro Ludovic Martin
    Chef de projet technique
    Inscrit en
    juillet 2002
    Messages
    96
    Détails du profil
    Informations personnelles :
    Nom : Homme Ludovic Martin
    Âge : 33
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : Chef de projet technique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : juillet 2002
    Messages : 96
    Points : 114
    Points
    114

    Par défaut

    En espérant que cela vous aidera car je ne sais pas si je réponds bien aux questions posées...

    Voici un code qui permet de charger un page via HTTPS sans ce soucier de la validé du certificat :
    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
    try{
        //Remplace le vérifieur de nom d'hôte par un autre moins restrictif
        HostnameVerifier hostnameVerifier=new HostnameVerifier(){
            public boolean verify(String urlHostName,SSLSession session){
                return true;
            }
        };
        HttpsURLConnection.setDefaultHostnameVerifier(hostnameVerifier);
     
        //Remplace le vérifieur de certificat par un autre moins restrictif
        TrustManager[] trustAllCerts=new TrustManager[]{
            new X509TrustManager(){
                public java.security.cert.X509Certificate[] getAcceptedIssuers(){return null;}
                public void checkClientTrusted(java.security.cert.X509Certificate[] certs,String authType){}
                public void checkServerTrusted(java.security.cert.X509Certificate[] certs,String authType){}
            }
        };
        SSLContext sslContext=SSLContext.getInstance("SSL");
        sslContext.init(null,trustAllCerts,new java.security.SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());            
     
     
        //Chargement de la page...
        URLConnection conn=new URL("https://www.trustxchange.com/").openConnection();
        BufferedReader br=new BufferedReader(new InputStreamReader(conn.getInputStream()));
        do{
            String ligne=br.readLine();
            if(ligne==null)break;
            System.out.println(ligne);
        }while(true);
     
    }catch(Exception ex){
        System.err.println(ex);
    }
    Je me suis basé là dessus en fait :
    http://www.exampledepot.com/egs/java.../TrustAll.html
    http://java.sun.com/products/plugin/1.2/docs/https.html

    Attention tout de même car question sécurité c'est loin d'être terrible étant donné que l'on n'est jamais certain de savoir "à qui on parle" avec ce code. Ca dépanne quoi...

  10. #10
    Membre éclairé Avatar de aJavaDeveloper
    Profil pro
    Inscrit en
    juin 2007
    Messages
    248
    Détails du profil
    Informations personnelles :
    Âge : 29
    Localisation : Belgique

    Informations forums :
    Inscription : juin 2007
    Messages : 248
    Points : 300
    Points
    300

    Par défaut Une petite clarification...

    Bonjour à tous !
    Une petite clarification ne me semble pas inutile...
    Il y a peut être des erreurs dans ce que je vais dire car il s'agit de mon interprétation personnelle.
    J'ai toutefois eu l'occasion d'implémenter un client pour un web service à contacter via HTTPS (avec passage par un proxy) et mon code fonctionne très bien.

    Lors d'une connexion SSL, deux scénarios sont envisageables.
    Le premier scénario est une authentification unilatérale : le serveur vous envoie son certificat afin de vous prouver son idendité.
    Le deuxième scénario est une authentification réciproque : le serveur vous envoie son certificat afin de vous prouver son idendité, vous envoyez votre propre certificat au serveur afin de lui prouver votre identité.

    Le deuxième scénario est généralement appliqué pour restreindre l'accès au web service.
    Notez que le certificat du serveur est généralement délivré par une autorité de certification (CA), alors que votre propre certificat vous est généralement délivré par l'entité responsable du web service, dans le cas d'une authentification réciproque.

    Il est également important de souligner que, lorsque vous désirez établir une connexion SSL, deux fichiers sont importants :
    • le keystore
    • le truststore

    Le keystore n'est utile que dans le cas d'une authentification réciproque. Il peut contenir plusieurs entrées. Chaque entrée est constituée d'un certificat ainsi que d'une clé privée qui vous sont propres.
    Le trustore contient, quant à lui, les certificats des entités en lesquels vous avez choisi d'avoir confiance. Ainsi, une communication SSL avec un web service ne sera possible que si vous avez placé le certificat de ce service dans votre trustore (ou en créant un 'all trusting manager', comme nous le verrons ci-dessous).

    Ca, c'est pour la théorie.

    En pratique, JSSE (Java Secure Socket Extension) met à votre disposition deux classes très pratiques :
    • KeyManager, un gestionnaire pour votre keystore
    • TrustManager, un gestionnaire pour votre truststore


    En ce qui concerne le trustManager, vous pouvez créer un 'all trusting manager', c'est-à-dire un manager qui accepte tous les certificats, grâce à la fonction suivante:
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
     
    public static TrustManager[] getAllTrustingTrustManager(){
    		return new TrustManager[]{
    				new X509TrustManager(){
    					public boolean checkClientTrusted(java.security.cert.X509Certificate[] chain){
    						return true;
    					}
    					public boolean isServerTrusted(java.security.cert.X509Certificate[] chain){
    						return true;
    					}
    					public boolean isClientTrusted(java.security.cert.X509Certificate[] chain){
    						return true;
    					}
    					public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    						return null;
    					}
    					public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
    					public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
    				}
    			};
    	}
    L'avantage de ce manager est qu'il vous permet de vous passer de trustore. L'inconvénient est qu'il n'est pas sécurisé.

    Si une authentification réciproque est requise, vous devez construire votre keystore (il existe pour cela des outils) et créer ensuite un keyManager de la façon suivante :
    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    char[] keystorepass = '<passwd>'.toCharArray();		//le mot de passe qui protège votre keystore
    File keystoreFile   = new File('<path>');		//le chemin d'accès à votre keystore
    KeyStore keyStore   = KeyStore.getInstance("JKS");
     
    keyStore.load(new FileInputStream(keystoreFile), keystorepass);
    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
    keyManagerFactory.init(keyStore, keystorepass);
    KeyManager[] keyManager = keyManagerFactory.getKeyManagers();	//voici votre keyManager
    Ensuite, vous devez initialiser votre context SSL.
    Pour une authentification réciproque :

    Code :
    1
    2
    3
     
    SSLContext sslContext = SSLContext.getInstance("TLS");
    sslContext.init(keyManager, trustManager, null);	//vous spécifiez le keyManager et le trustManager créés plus haut
    Pour une authentification unilatérale:

    Code :
    1
    2
    3
     
    SSLContext sslContext = SSLContext.getInstance("TLS");
    sslContext.init(null, trustManager, null);		//vous spécifiez le trustManager créé plus haut et un keyManager null
    Enfin, il ne vous reste plus qu'à ouvrir une connexion :

    Code :
    1
    2
    3
     
    HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
    HttpsURLConnection connection = (HttpsURLConnection)request.getUrl().openConnection();
    Pour faire passer la connexion ci-dessus via un proxy, il suffit de définir l'adresse et le port du proxy de la façon suivante :

    Code :
    1
    2
    3
     
    System.setProperty("http.proxyHost", "...");	//l'adresse du proxy
    System.setProperty("http.proxyPort", "...");	//le port du proxy
    Voilà, c'est tout.
    J'espère avoir été clair et que ceci vous aidera...

  11. #11
    Membre éclairé Avatar de aJavaDeveloper
    Profil pro
    Inscrit en
    juin 2007
    Messages
    248
    Détails du profil
    Informations personnelles :
    Âge : 29
    Localisation : Belgique

    Informations forums :
    Inscription : juin 2007
    Messages : 248
    Points : 300
    Points
    300

    Par défaut Au cas où une authentification proxy serait nécessaire...

    J'ai oublié de parler d'un petit truc.
    Lorsque vous désirez établir une connexion via un proxy, il se peut que ce proxy vous demande de vous authentifier (généralement via login/password).
    Pour ce faire, utilisez la classe suivante :

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     
    public class SimpleAuthenticator extends Authenticator
    {
       private String username,   password;
     
       public SimpleAuthenticator(String username,String password) {
          this.username = username;
          this.password = password;
       }
     
       protected PasswordAuthentication getPasswordAuthentication() {
          return new PasswordAuthentication(username,password.toCharArray());
       }
    }
    Ensuite, juste avant d'établir votre connexion, au moment où vous définissez vos paramètres proxy (voir message précédent), faites

    Code :
    1
    2
     
    Authenticator.setDefault(new SimpleAuthenticator(username,password));
    J'ai trouvé ce code à l'adresse suivante : http://www.developer.com/java/other/article.php/1551421.

    Je ne l'ai pas testé...

    A +

  12. #12
    Invité de passage
    Inscrit en
    juillet 2007
    Messages
    1
    Détails du profil
    Informations forums :
    Inscription : juillet 2007
    Messages : 1
    Points : 1
    Points
    1

    Par défaut

    J'ai essayé le code ci-dessus et ça marche, mais avec une petite précision, il fallait utiliser :

    Code :
    1
    2
    3
    System.setProperty("https.proxyHost", "...");	//l'adresse du proxy
    System.setProperty("https.proxyPort", "...");	//le port du proxy
    Un exemple entier :

    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
     
     
    import java.io.OutputStreamWriter;
    import java.io.BufferedReader;
    import java.util.Properties;
    import java.net.URL;
    import java.net.URLConnection;
    import java.io.InputStreamReader;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.TrustManager;
    import javax.net.ssl.X509TrustManager;
    import javax.net.ssl.HttpsURLConnection;
    import java.security.cert.*;
    import java.net.Authenticator;
     
    public class TestProxy{
     
    	public TestProxy(String proxy, String proxyport, String address)
    	{   
     
    		OutputStreamWriter writer = null;   
    		BufferedReader reader = null;   
    		try { 
     
    		System.out.println("constructor TestProxy :: proxy="+proxy+" proxyport="+proxyport+" address="+address); 
     
    		//System.setProperty("http.proxySet","true");
    		System.setProperty("https.proxyHost",proxy);
    		System.setProperty("https.proxyPort",proxyport);
    		SimpleAuthenticator sa =  new SimpleAuthenticator("le_login" , "le_mot_de_passe");
    		Authenticator.setDefault(sa);
     
    		URL url = new URL(address);
    		if (url.getProtocol().equalsIgnoreCase("HTTPS")) 
    		{
    			System.out.println("Protocol HTTPS");  
    			SSLContext sslContext = SSLContext.getInstance("SSLV3");
     
    			TrustManager[] trustManagerArray = getAllTrustingTrustManager();
     
    			sslContext.init(null, trustManagerArray, null); 
    			HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
    			HttpsURLConnection connection = (HttpsURLConnection)url.openConnection();
    			reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));  
    		}
    		else
    		{
    			System.out.println("Protocol HTTP");  
    			URLConnection connection = url.openConnection();
    			reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
    		}
     
     
    		String ligne;        
     
    		while ((ligne = reader.readLine()) != null) 
    		{         
    			System.out.println("\t"+ligne);        
    		}  
     
    		System.out.println("\n\nEND!!");        
    		}
    		catch (Exception e) {      
    		// affichage de la trace en cas d'exception      
    		e.printStackTrace();   }
     
    		finally{      try{  writer.close();  }      
    		catch(Exception e){e.printStackTrace();}      
     
    		try{  reader.close();         }      
    		catch(Exception e){e.printStackTrace();}   }
     
    	}
     
    	public static void main (String[] args){ 
    		if (args.length<3)
    	  {
    			System.out.println("Usage : java TestProxy <proxy url> <proxy port> <url> ");
    			return;
    	  }
     
    	 	System.out.println("TestProxy main() starting ...");   
     
    	 	TestProxy tp = new TestProxy(args[0], args[1],args[2]);
    	 	System.out.println("\n\nTestProxy END"); 
    	}
     
    	public class SimpleAuthenticator extends java.net.Authenticator {
    	private String username, password;
     
    	public SimpleAuthenticator() {
    		super();
    	}
     
    	public SimpleAuthenticator(String username, String password) {
    		this.username = username;
    		this.password = password;
    	}
     
    	protected java.net.PasswordAuthentication getPasswordAuthentication() {
    		return new java.net.PasswordAuthentication(username, password
    				.toCharArray());
    	}
    }
     
    	public static TrustManager[] getAllTrustingTrustManager(){
    		return new TrustManager[]{
    			new X509TrustManager(){
    				public boolean checkClientTrusted(java.security.cert.X509Certificate[] chain){
    				return true;
    				}
    				public boolean isServerTrusted(java.security.cert.X509Certificate[] chain){
    					return true;
    				}
    				public boolean isClientTrusted(java.security.cert.X509Certificate[] chain){
    					return true;
    				}
    				public java.security.cert.X509Certificate[] getAcceptedIssuers() {
    					return null;
    				}
    				public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
    				public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {}
    			}
    		};
    	}
     
    }

    pour tester : java TestProxy ip_proxy no_port_proxy https://xxxxxx

  13. #13
    Membre du Club
    Inscrit en
    mai 2008
    Messages
    124
    Détails du profil
    Informations forums :
    Inscription : mai 2008
    Messages : 124
    Points : 64
    Points
    64

    Par défaut

    je fais un petit up sur ce sujet !!
    Je voudrais savoir comment fait on pour ne pas accepter tous les certificats mais seulement un certificat que l'on à déjà ???
    En effet j'ai le certificat du serveur ou je veux lire mon fichier !!
    Comment faire pour n'accepter que celui-ci ?

  14. #14
    Invité de passage
    Homme Profil pro
    Consultant informatique
    Inscrit en
    mars 2011
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : mars 2011
    Messages : 3
    Points : 4
    Points
    4

    Par défaut mise à jour URL keyTool IUI

    ( ou avec l'excelent outil KeyTool IUI http://ragingcat.developpez.com/java/outils/keytool/ui/ )
    Pour info, le nouveau lien est
    keyTool IUI

    keyTool IUI est désormais open-source, sous license GNU-LGPL

  15. #15
    Membre habitué
    Inscrit en
    juin 2004
    Messages
    212
    Détails du profil
    Informations forums :
    Inscription : juin 2004
    Messages : 212
    Points : 129
    Points
    129

    Par défaut

    Salut tout le monde, je remonte ce post car j'ai un petit soucis lorsque j'essaye d'aller chercher une image sur un serveur HTTPS j'ai l'erreur suivante :
    Code :
    java.net.UnknownHostException
    Donc cette erreur ne m'aide pas beaucoup!!

    Code :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    addrImage = new URL(m_sAdresseServeur + m_tNomFichiersSource);
     
    //Ouverture de la connexion
    HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
    urlCon = (HttpsURLConnection)addrImage.openConnection();
     
    // On authorise la lecture et l'écriture sur le serveur 
    auth = new String(m_sUser + ":" + m_sPwd);
    b64 = new BASE64Encoder();
    urlCon.setRequestProperty ("Authorization", "Basic " + b64.encode(auth.getBytes()));
    urlCon.setUseCaches(false);
    urlCon.setDoOutput(true);
     
    try {
    	// Get the response.
    	m_logger.debug("Récupération de l'image : " +   m_tNomFichiersSource[i]);
    	iStr = urlCon.getInputStream();
     
            image = ImageIO.read(iStr);
    } catch (Exception e) {
    	m_logger.error("Description : " + e);
    }
    c'est lors de l'appel à
    Code :
    iStr = urlCon.getInputStream();
    que ça plante et que j'ai l'erreur.

    J'espère que vous pourrez m'aider.

  16. #16
    Membre éclairé Avatar de rockley
    Homme Profil pro
    Inscrit en
    décembre 2010
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Arménie

    Informations forums :
    Inscription : décembre 2010
    Messages : 346
    Points : 301
    Points
    301

    Par défaut

    java.net.UnknownHostException
    Ton URL est faux

    http://www.developpez.net/forums/d98...n-c-saxparser/

    java.net.UnknownHostException dans google suffit.
    Ce poste est une référence (pour moi). Ne le remonte pas pour rien.

  17. #17
    Membre habitué
    Inscrit en
    juin 2004
    Messages
    212
    Détails du profil
    Informations forums :
    Inscription : juin 2004
    Messages : 212
    Points : 129
    Points
    129

    Par défaut

    Merci pour ta réponse et pour le lien mais ça ne répond pas à ma question car j'ai déjà vérifier plusieurs fois

    C'est pour ça que je me suis permis de remonter ce sujet car il correspond exactement à mon problème.

  18. #18
    Membre éclairé Avatar de rockley
    Homme Profil pro
    Inscrit en
    décembre 2010
    Messages
    346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Arménie

    Informations forums :
    Inscription : décembre 2010
    Messages : 346
    Points : 301
    Points
    301

    Par défaut

    car il correspond exactement à mon problème.
    D'abord, je m'excuse pour mon agressivité.
    Je ne dis pas que ça te concerne pas. Tu peux avoir une authentification à réaliser, mais c'est juste que l'erreur n'a rien avoir.
    Pour pouvoir t'authentifier il faut déjà que tu puisses joindre le serveur.
    Et là, apparemment tu n'arrives même pas jusqu'à ton serveur.
    ça viens surement de ton endpoint.

    Test :
    ping <hostname> dans l'invite. Là t'auras pas de web service.
    Si t'as un truc du genre Unknown Host, tu seras fixé.

    Si t'as l'url de ton endpoint, convertie ton keyStore.jks en *.pk12, met le certif. dans ton firefox et voie si tu accèdes au WSDL.

    Si tu dois passer un proxy :
    Properties p = System.getProperties();
    p.put("http.proxyHost","http-proxy.xx.xxxxx.xx");
    p.put("http.proxyPort","8080");
    System.setProperties(p);

    Si non, crées un autre post, sois plus précis, met tes logs en entier et je serai ravis de t'aider. Pour l'instant, juste avec UnknownHostException, la réponse reste la même. Fait un print de ton URL également.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •