android httpClient 支持HTTPS的2种处理方式

来源：互联网发布：php程序员有必要学c吗编辑：程序博客网时间：2024/05/24 06:29

android httpClient 支持HTTPS的2种处理方式

问题：

项目中Android https或http请求地址重定向为HTTPS的地址，相信很多人都遇到了这个异常(无终端认证)：
javax.net.ssl.SSLPeerUnverifiedException: No peer certificate

解决过程：

1.没遇到过的问题，搜索吧，少年

log里出现这个异常，作者第一次遇到，不知道啥意思。看下字面意思，是ssl协议中没有终端认证。SSL?作者没用到ssl协议呀，只是通过httpClient请求一个重定向https的地址。
好吧，google下，知道了个差不多情况的帖子，http://www.eoeandroid.com/thread-161747-1-1.html。恩恩，一个不错的帖子，给出了个解决方案。照着来试下。添加个继承SSLSocketFactory的
自定义类。并在初始化httpclient支持https时，注册进去。看下面代码：

?
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
public class HttpClientHelper {
 
    privatestatic HttpClient httpClient;
 
    privateHttpClientHelper() {
    }
 
    publicstatic synchronizedHttpClient getHttpClient() {
 
        if(null == httpClient) {
            // 初始化工作
            try{
                KeyStore trustStore = KeyStore.getInstance(KeyStore
                        .getDefaultType());
                trustStore.load(null,null);
                SSLSocketFactory sf =new SSLSocketFactoryEx(trustStore);
                sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER); //允许所有主机的验证
 
                HttpParams params =new BasicHttpParams();
 
                HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
                HttpProtocolParams.setContentCharset(params,
                        HTTP.DEFAULT_CONTENT_CHARSET);
                HttpProtocolParams.setUseExpectContinue(params,true);
 
                // 设置连接管理器的超时
                ConnManagerParams.setTimeout(params,10000);
                // 设置连接超时
                HttpConnectionParams.setConnectionTimeout(params,10000);
                // 设置socket超时
                HttpConnectionParams.setSoTimeout(params,10000);
 
                // 设置http https支持
                SchemeRegistry schReg =new SchemeRegistry();
                schReg.register(newScheme("http", PlainSocketFactory
                        .getSocketFactory(),80));
                schReg.register(newScheme("https", sf,443));
 
                ClientConnectionManager conManager =new ThreadSafeClientConnManager(
                        params, schReg);
 
                httpClient =new DefaultHttpClient(conManager, params);
            }catch (Exception e) {
                e.printStackTrace();
                returnnew DefaultHttpClient();
            }
        }
        returnhttpClient;
    }
 
}
 
class SSLSocketFactoryEx extends SSLSocketFactory {
 
    SSLContext sslContext = SSLContext.getInstance("TLS");
 
    publicSSLSocketFactoryEx(KeyStore truststore)
            throwsNoSuchAlgorithmException, KeyManagementException,
            KeyStoreException, UnrecoverableKeyException {
        super(truststore);
 
        TrustManager tm =new X509TrustManager() {
 
            @Override
            publicjava.security.cert.X509Certificate[] getAcceptedIssuers() {
                returnnull;
            }
 
            @Override
            publicvoid checkClientTrusted(
                    java.security.cert.X509Certificate[] chain, String authType)
                    throwsjava.security.cert.CertificateException {
 
            }
 
            @Override
            publicvoid checkServerTrusted(
                    java.security.cert.X509Certificate[] chain, String authType)
                    throwsjava.security.cert.CertificateException {
 
            }
        };
 
        sslContext.init(null,new TrustManager[] { tm },null);
    }
 
    @Override
    publicSocket createSocket(Socket socket, String host, intport,
            booleanautoClose) throwsIOException, UnknownHostException {
        returnsslContext.getSocketFactory().createSocket(socket, host, port,
                autoClose);
    }
 
    @Override
    publicSocket createSocket() throwsIOException {
        returnsslContext.getSocketFactory().createSocket();
    }
}

ok，run下，狂乱的点到测试按钮，深吸口气，盯着eclipse中的logat。咦？神奇的竟然没有报之前的 javax.net.ssl.SSLPeerUnverifiedException: No peer certificate的异常了。服务端的数据正常返回了。,狂喜中...

2.了解并分析问题

狂喜中，得分析这问题诶。不然老大来问，啥情况？楞半天不知道咋说（作者就经常这样，所以吸取教训。所以的弄懂出现的问题，学习+汇报工作）。
思来想去，就是作者请求的是一个重定向https的地址。好吧，那就学习下https（之前被老大深深的教过，http就是request/response）。继续搜索吧，少年。下面总结下学习到的https知识。

2.1 https

HTTPS:超文本安全传输协议，和HTTP相比，多了一个SSL/TSL的认证过程，端口为443。（鄙视下之前说的)

作者没用到ssl协议呀，只是通过httpClient请求一个重定向https的地址

1.peer终端发送一个request，https服务端把支持的加密算法等以证书的形式返回一个身份信息（包含ca颁发机构和加密公钥等）。

2.获取证书之后，验证证书合法性。

3.随机产生一个密钥，并以证书当中的公钥加密。

4.request https服务端，把用公钥加密过的密钥传送给https服务端。

5.https服务端用自己的密钥解密，获取随机值。

6.之后双方传送数据都用此密钥加密后通信。

看下面一张网上的得来的https的时序图：

2.2分析下出现问题的原因

好吧，大概的流程知道了。定位已经非常清楚了。在第2步验证证书时，无法验证。为啥无法验证呢？没有添加信任。详细参考下

http://www.cnblogs.com/P_Chou/archive/2010/12/27/https-ssl-certification.html讲的非常清楚https-ssl的认证过程，膜拜下该作者

这样想来，上面提供的解决方案就是添加默认信任全部证书。以此来通过接下来的通信。

3.解决问题

但是，这样问题是解决了。但是觉得还是不带靠谱（信任全部证书有点危险）。继续噼噼啪啪的网上搜索一番。又找到了一种解决方案，其过程大致这样的：

1.浏览器访问https地址，保存提示的证书到本地，放到android项目中的assets目录。

2.导入证书，代码如下。

3.把证书添加为信任。

?
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
String requestHTTPSPage(String mUrl) {
        InputStream ins =null;
        String result ="";
        try{
            ins = context.getAssets().open("app_pay.cer");//下载的证书放到项目中的assets目录中
            CertificateFactory cerFactory = CertificateFactory
                    .getInstance("X.509");
            Certificate cer = cerFactory.generateCertificate(ins);
            KeyStore keyStore = KeyStore.getInstance("PKCS12","BC");
            keyStore.load(null,null);
            keyStore.setCertificateEntry("trust", cer);
 
            SSLSocketFactory socketFactory =new SSLSocketFactory(keyStore);
            Scheme sch =new Scheme("https", socketFactory,443);
            HttpClient mHttpClient =new DefaultHttpClient();
            mHttpClient.getConnectionManager().getSchemeRegistry()
                    .register(sch);
 
            BufferedReader reader =null;
            try{
                Log.d(TAG,"executeGet is in,murl:" + mUrl);
                HttpGet request =new HttpGet();
                request.setURI(newURI(mUrl));
                HttpResponse response = mHttpClient.execute(request);
                if(response.getStatusLine().getStatusCode() != 200) {
                    request.abort();
                    returnresult;
                }
 
                reader =new BufferedReader(newInputStreamReader(response
                        .getEntity().getContent()));
                StringBuffer buffer =new StringBuffer();
                String line =null;
                while((line = reader.readLine()) != null) {
                    buffer.append(line);
                }
                result = buffer.toString();
                Log.d(TAG,"mUrl=" + mUrl +"\nresult = " + result);
            }catch (Exception e) {
                e.printStackTrace();
            }finally {
                if(reader != null) {
                    reader.close();
                }
            }
        }catch (Exception e) {
            // TODO: handle exception
        }finally {
            try{
                if(ins != null)
                    ins.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
        }
        returnresult;
    }

接着，验证下呗。吼吼，稀里糊涂的又可以了。感动的泪流满面。

最后总结：

2种方法都解决了作者遇到的问题，这里记录下。以防下次遇到，希望能给遇到相同问题朋友有所参考帮助。

http://my.oschina.net/blackylin/blog/144136

0 0