KSOAP 2 Android avec HTTPS

Je suis en utilisant KSOAP2 pour gérer le SAVON dans Android, mais il utilise le protocole https pour le SAVON url et j'obtiens cette erreur: javax.net.le protocole ssl.SSLException: Pas de confiance certificat de serveur
Une erreur normal car le certificat n'est pas approuvé, mais quelqu'un sait comment contourner cette erreur?
Je ne peux pas gérer le certificat parce que c'est à partir d'une autre entreprise et je n'ai pas accès à la changer.

Grâce

OriginalL'auteur rallat | 2010-08-09

  1. 10

    Je ne peux pas encore de commentaires donc je poste mes commentaires à rallat réponse ici. Sa solution fonctionne, mais il a besoin de plus d'explications. Pour exécuter ksoap2 avec ssl:

    1. Mettre ksoap2-android-assembly-2.5.2-jar-with-dependencies.jar dans un projet
    2. Télécharger ksoap2 sources de https://github.com/mosabua/ksoap2-android/tree/ (ksoap2 référentiel)
    3. Copie HttpTransportSE.java, ServiceConnectionSE.java (j'ai aussi besoin de copier Transport.java, ServiceConnection.java et HeaderProperty.java). Supprimer les importations en provenance de ces fichiers et assurez-vous qu'ils utilisent vos fichiers (pas les importations de ksoap2.jar)

    4. Utilisation rallat réponse ( je copie-collé):

      • ServiceConnectionSE.java ajouter ce pour accepter les certificats non fiables:

        private 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) {
        }
    }
};

      • ensuite utiliser ces constructeurs pour
        permettre de certificats non fiables et non
        vérifié les noms d'hôtes:

        public ServiceConnectionSE(String url) throws IOException {
    try {
        SSLContext sc = SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
    } catch (Exception e) {
        e.getMessage();
    }
    connection = (HttpsURLConnection) new URL(url).openConnection();
    ((HttpsURLConnection) connection).setHostnameVerifier(new AllowAllHostnameVerifier());
}

      • Deuxième constructeur

        public ServiceConnectionSE(Proxy proxy, String url) throws IOException {
    try {
        SSLContext sc = SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
     } catch (Exception e) {
        e.getMessage();
     }
     connection = (HttpsURLConnection) new URL(url).openConnection();
    ((HttpsURLConnection) connection).setHostnameVerifier(new AllowAllHostnameVerifier());

    connection.setUseCaches(false);
    connection.setDoOutput(true);
    connection.setDoInput(true);
}

    5. Dans votre code utilisation: 

      HttpTransportSE aht = new HttpTransportSE(URL);    
aht.call(SOAP_ACTION, envelope);

    D'autres choses que des tutoriels

    pour ur réponse, il a aidé...j'avais hâte de savoir plutôt que de travailler autour de si Avait le Certificat de Sécurité...Comment puis-je aller plus loin avec elle..?
    Ne pouvez pas trouver les sources de ksoap à l'aide de la condition de lien cassé. =\ mise à jour: j'ai trouvé ça... il suffit d'utiliser :github.com/mosabua/ksoap2-android

    OriginalL'auteur

  2. 16

    De vérifier à nouveau ce problème, j'ai découvert plus de solution propre pour moi. Pas de KSOAP2 modification des fichiers nécessaires.

    Dans votre projet, en lien la ksoap2-android-assembly-3.0.0-jar, sans aucune modification.

    Ensuite, créez un fichier nommé SSLConnection.java avec ce code:

    package com.example.mypackage;
import android.util.Log;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
public class SSLConection {
private static TrustManager[] trustManagers;
public static class _FakeX509TrustManager implements javax.net.ssl.X509TrustManager {
private static final X509Certificate[] _AcceptedIssuers = new X509Certificate[]{};
public void checkClientTrusted(X509Certificate[] arg0, String arg1)
throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] arg0, String arg1)
throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return (_AcceptedIssuers);
}
}
public static void allowAllSSL() {
javax.net.ssl.HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
return true;
}
});
javax.net.ssl.SSLContext context;
if (trustManagers == null) {
trustManagers = new TrustManager[]{new _FakeX509TrustManager()};
}
try {
context = javax.net.ssl.SSLContext.getInstance("TLS");
context.init(null, trustManagers, new SecureRandom());
javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());
} catch (NoSuchAlgorithmException e) {
Log.e("allowAllSSL", e.toString());
} catch (KeyManagementException e) {
Log.e("allowAllSSL", e.toString());
}
}
}

    Et il suffit d'appeler à SSLConection.allowAllSSL(); avant d'appeler une méthode de serveur via KSOAP2. Tout fonctionne pour moi. Tous les certificats SSL sont acceptés et que je peux utiliser KSOAP2 avec le protocole https.

    Merci pour l'ajout de votre extrait de trop
    Parfaite solution simple! Merci 🙂
    heureux de vous aider! 🙂
    C'est très dangereux de la solution de contournement. Vous laisse exposé aux attaques de type MITM.
    Ne fonctionne pas sur Android 4.2

    OriginalL'auteur

  3. 4

    J'ai trouver la réponse par moi-même

    • sur ServiceConnectionSE.java ajouter ce pour accepter les certificats non fiables:

      private 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) {
}
}
};

    • puis dans le constructeur d'ajouter ce pour permettre de certificats non fiables et non pas vérifié les noms d'hôtes:

          try {
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, trustAllCerts, new java.security.SecureRandom());
HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
} catch (Exception e) {
e.getMessage();
}
connection = (HttpsURLConnection) new URL(url).openConnection();
((HttpsURLConnection) connection).setHostnameVerifier(new AllowAllHostnameVerifier());

    OriginalL'auteur

  4. 4

    Créer une nouvelle classe FakeX509TrustManager pour traiter le problème de certificat,

        FakeX509TrustManager.allowAllSSL();
HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

    La nouvelle de la classe est la suivante:

    public class FakeX509TrustManager implements X509TrustManager { 
private static TrustManager[] trustManagers; 
private static final X509Certificate[] _AcceptedIssuers = new 
X509Certificate[] {}; 
@Override 
public void checkClientTrusted(X509Certificate[] chain, String 
authType) throws CertificateException { 
} 
@Override 
public void checkServerTrusted(X509Certificate[] chain, String 
authType) throws CertificateException { 
} 
public boolean isClientTrusted(X509Certificate[] chain) { 
return true; 
} 
public boolean isServerTrusted(X509Certificate[] chain) { 
return true; 
} 
@Override 
public X509Certificate[] getAcceptedIssuers() { 
return _AcceptedIssuers; 
} 
public static void allowAllSSL() { 
HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() 
{ 
@Override 
public boolean verify(String hostname, SSLSession session) { 
return true; 
} 
}); 
SSLContext context = null; 
if (trustManagers == null) { 
trustManagers = new TrustManager[] { new FakeX509TrustManager() }; 
} 
try { 
context = SSLContext.getInstance("TLS"); 
context.init(null, trustManagers, new SecureRandom()); 
} catch (NoSuchAlgorithmException e) { 
e.printStackTrace(); 
} catch (KeyManagementException e) { 
e.printStackTrace(); 
} 
HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory()); 
} 
}
    Grave +1 jowett...j'ai mis ton code à la fin de mon activité et de tout ce que j'avais à faire était de faire de la FakeX509TrustManager statique et elle a eu droit à travers...j'ai lu plus que quelques SORTE postes et c'était le plus facile à mettre en œuvre, et de loin. Notez les dates sur les réponses précédentes dans ce post...j'en ai assez dit. Vous avez toutes les ressources sur la façon la plus simple de ne PAS faire confiance à tous les certs pour la production de code?
    désolé, pas de ressource.

    OriginalL'auteur