带有 HTTPS 的 KSOAP 2 Android

Question

我正在使用 KSOAP2 来管理 Android 中的 SOAP，但它使用 https 作为 SOAP url，并且收到此错误：javax.net.ssl.SSLException：不受信任的服务器证书
这是一个正常错误，因为证书不受信任，但有人知道如何解决此错误吗？ 我无法管理该证书，因为该证书来自其他公司，并且我无权更改它。

谢谢

Answer 1

再次检查这个问题，我发现了一个更干净的解决方案。无需修改 KSOAP2 文件。

在您的项目中，链接 ksoap2-android-assemble-3.0.0-jar，无需任何修改。

接下来，使用以下代码创建一个名为 SSLConnection.java 的文件：

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());
        }
    }
}

在通过 KSOAP2 调用服务器方法之前，只需调用 SSLConection.allowAllSSL(); 即可。这一切，对我有用。所有 SSL 证书都被接受，我可以使用带有 https 协议的 KSOAP2。

Answer 2

我还不能发表评论，所以我将我的评论发布到这里的 rallat 答案。他的解决方案有效，但需要进一步解释。要使用 ssl 运行 ksoap2：

1. 将 ksoap2-android-assemble-2.5.2-jar-with-dependency.jar 放入项目中
2. 从 https://github.com/mosabua/ksoap2-android/tree/（ksoap2 存储库）
3. 复制 HttpTransportSE.java, ServiceConnectionSE.java（我还需要复制 Transport.java、ServiceConnection.java 和 HeaderProperty.java）。删除这些文件中的导入并确保它们使用您的文件（不是从 ksoap2.jar 导入）

4. 使用 rallat 答案（我复制粘贴它）：

   • ServiceConnectionSE.java 添加此内容以接受不受信任的证书：

     私有 TrustManager[] trustAllCerts = new TrustManager[] {
         新的 X509TrustManager() {
             公共 java.security.cert.X509Certificate[] getAcceptedIssuers() {
                 返回空值；
             }
             公共无效检查客户端信任（
                 java.security.cert.X509Certificate[] 证书，字符串 authType) {
             }
             公共无效检查服务器可信（
                 java.security.cert.X509Certificate[] 证书，字符串 authType) {
             }
         }
     };
     

   • 然后使用这个构造函数
     允许不受信任的证书，并且不允许
     已验证的主机名：

     public ServiceConnectionSE(String url) throws IOException {
         尝试 {
             SSLContext sc = SSLContext.getInstance("TLS");
             sc.init(null, trustAllCerts, new java.security.SecureRandom());
             HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
         } catch (异常 e) {
             e.getMessage();
         }
         连接 = (HttpsURLConnection) 新 URL(url).openConnection();
         ((HttpsURLConnection) 连接).setHostnameVerifier(new AllowAllHostnameVerifier());
     }    
     

   • 第二个构造函数

     public ServiceConnectionSE(Proxy proxy, String url) throws IOException {
         尝试 {
             SSLContext sc = SSLContext.getInstance("TLS");
             sc.init(null, trustAllCerts, new java.security.SecureRandom());
             HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
          } catch (异常 e) {
             e.getMessage();
          }
          连接 = (HttpsURLConnection) 新 URL(url).openConnection();
         ((HttpsURLConnection) 连接).setHostnameVerifier(new AllowAllHostnameVerifier());
     
         连接.setUseCaches(false);
         连接.setDoOutput(true);
         连接.setDoInput(true);
     }
     

5. 在您的代码中只需使用：

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

教程中的其他内容

Answer 3

我自己找到答案

• 在 ServiceConnectionSE.java 上添加此内容以接受不受信任的证书：

  私有 TrustManager[] trustAllCerts = 新 TrustManager[]{
      新的 X509TrustManager() {
          公共 java.security.cert.X509Certificate[] getAcceptedIssuers() {
              返回空值；
          }
          公共无效检查客户端信任（
              java.security.cert.X509Certificate[] 证书，字符串 authType) {
          }
          公共无效检查服务器可信（
              java.security.cert.X509Certificate[] 证书，字符串 authType) {
          }
      }
  };
  

• 然后在构造函数中添加此内容以允许不受信任的证书和未经验证的主机名：

  <前><代码>尝试{
  SSLContext sc = SSLContext.getInstance("TLS");
  sc.init(null, trustAllCerts, new java.security.SecureRandom());
  HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
  } catch (异常 e) {
  e.getMessage();
  }
  连接 = (HttpsURLConnection) 新 URL(url).openConnection();
  ((HttpsURLConnection) 连接).setHostnameVerifier(new AllowAllHostnameVerifier());

Answer 4

创建一个新类FakeX509TrustManager来处理证书问题，

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

新创建的类如下：

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()); 
    } 

}