OTA服务器和android客户端添加HTTPS协议

有段时间没总结了，这期间主要学习三个问题:

一是https协议，OTA HTTPS 协议可以工作了。

二是消息推送，推送用的是openfire+asmack方案，目前只能给所有用户广播消息，如果针对不同项目用户，服务器端还需要单独开发插件支持，这个后面继续研究。

三是服务器并发压力测试，测试工具用的是jmeter，这个工具还是很强大的，可以同时模拟成千上万的用户同时访问服务器。

知识点很多，很多还是一知半解的。

一、HTTPS协议

       HTTPS 协议主要是为了解决安全问题，在HTTP到TCP层之间加入SSL/TLS层，ssl提供了身份验证和通信加密。

      下图是一张双向认证的tcpdump log，可以看出HTTPS协议的基本工作流程。

      1. 首先执行基本的TCP三步握手

       2. 客户端给服务器发client hello问候语，问候语中包含客户端支持的加密算法，压缩算法，SSL/TLS 版本，随机数 

       3. 服务器响应问候语，返回server hello问候语，问候语中包含客户端的随机数，确定的通信加密算法。

       4.服务器把自己的证书发给客户端，告诉客户端说我这台服务器是合法的，不信可以用CA去校验。此时客户端可以通过CA（CA可以自己生成）去校验

         如果合法就继续访问，不合法就提示用户等处理。

       5.同时服务器也需要验证客户端是不是合法的，所以它请求客户端提供自己的证书。此时客户端就把证书发给服务器。

       6. 如果都双方证书都验证通过，就开始进行加密过程试通信，如果数据解析都没问题，就开始正式传输数据。

    


二、 服务器端配置

       1. 首先通过openssl 生成证书

        1）.生成私钥：  

openssl genrsa -out private/server.key 1024

也可以生成加密的私钥，但是windows 上的wamp和xampp 不支持加密的。
openssl genrsa -des3 -out server.key 1024 
2).生成证书请求文件，用这个文件拿去给CA签名。
openssl req -new -key private/server.key -out crl/server.csr
3）用同样的办法生成root.key (自己做的CAkey)和 client.key
4) 用CA key 分别签名server 和 client key

openssl x509 -req -days 3650 -sha1 -extensions v3_ca -signkey root.key -in server.csr -out server.crt
openssl x509 -req -days 3650 -sha1 -extensions v3_ca -signkey root.key -in client.csr -out client.crt

5) 对于xampp ,默认已经打开ssl，但是支持单向认证，所以还需要把httpd-ssl.conf 里的如下项打开，并把root.crt和server.key server.crt证书放到 相应位置
SSLCACertificateFile "conf/otaserver.key/root.crt"
SSLVerifyClient require

SSLVerifyDepth  10
把DocumentRoot和ServerName配置好，可以临时定义一个域名，用于局域网。ServerName 应该和 server证书里面的common name一致。
DocumentRoot "C:/xampp/htdocs/otaserver"

ServerName www.xxx.ota.com:443
6）对于linux系统也差不多配置，这里不再描述。
二 、在浏览器上验证
先用client key生成浏览器用的pfx文件
openssl pkcs12 -export -clcerts -in client.crt -inkey client.key -out client.pfx
把root.crt 安装到浏览器的受信任的证书颁发机构，再点击安装client.pfx。
三、 android 客户端
1. 把client.pfx和root.crt 放到应用assets目录下
2. 添加相关代码

private static final String keyStoreFileName ="client.pfx";
private static final String keyStorePassword ="123456";
private static final String trustStoreFileName ="root.crt";
private static final String trustStorePassword ="123456";
try {
CertificateFactory cf = CertificateFactory.getInstance("X.509");
InputStream caInput = ct.getResources().getAssets().open(trustStoreFileName);
final Certificate ca;
try {
ca = cf.generateCertificate(caInput);
Log.d(TAG, "ca=" + ((X509Certificate) ca).getSubjectDN());
Log.d(TAG, "key=" + ((X509Certificate) ca).getPublicKey());
} finally {
caInput.close();
}

HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
Log.d(TAG,"verify hostname:"+hostname);
return true;
}
});

KeyManager[] keyManagers = createKeyManagers(ct,keyStoreFileName,keyStorePassword,alias);
SSLContext context = SSLContext.getInstance("TLSv1","AndroidOpenSSL");
context.init(keyManagers, new TrustManager[]{
new X509TrustManager() {
@Override
public void checkClientTrusted(X509Certificate[] chain,
String authType)
throws CertificateException {

}

@Override
public void checkServerTrusted(X509Certificate[] chain,
String authType)
throws CertificateException {
Log.d(TAG,"checkServerTrusted authType:" + authType);
for (X509Certificate cert : chain) {

// Make sure that it hasn't expired.
cert.checkValidity();
Log.d(TAG,"checkServerTrusted cert:" + cert.getPublicKey());
// Verify the certificate's public key chain.
try {
cert.verify(((X509Certificate) ca).getPublicKey());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
throw new CertificateException(e);
} catch (InvalidKeyException e) {
e.printStackTrace();
throw new CertificateException(e);
} catch (NoSuchProviderException e) {
e.printStackTrace();
throw new CertificateException(e);
} catch (SignatureException e) {
e.printStackTrace();
throw new CertificateException(e);
}
}
}

@Override
public X509Certificate[] getAcceptedIssuers() {
Log.d(TAG,"getAcceptedIssuers");
return new X509Certificate[0];
}
}
}, null);

StringBuilder sb = new StringBuilder();
if(params!=null && !params.isEmpty()){

for(Map.Entry<String, String> entry : params.entrySet()){
sb.append(entry.getKey()).append('=')
.append(URLEncoder.encode(entry.getValue(), enc))
.append('&');
}
sb.deleteCharAt(sb.length()-1);
}
Log.d(TAG,"post: send_data:" + sb.toString());

byte[] entitydata = sb.toString().getBytes();
URL url = new URL(path);
HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
conn.setSSLSocketFactory(context.getSocketFactory());
conn.setDefaultHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String hostname, SSLSession session) {
//TODO Auto-generated method stub
Log.d(TAG,"verify hostname:"+hostname);
return true;
}
});
conn.setRequestMethod("POST");
conn.setConnectTimeout(50 * 1000);

conn.setDoOutput(true);

//Content-Type: application/x-www-form-urlencoded
//Content-Length: 38
conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
conn.setRequestProperty("Content-Length", String.valueOf(entitydata.length));

OutputStream outStream = conn.getOutputStream();
outStream.write(entitydata);
outStream.flush();
outStream.close();
if(conn.getResponseCode()==200){
StringBuffer buffer = new StringBuffer();
try {
BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
String temp;
while ((temp = br.readLine()) != null) {
buffer.append(temp);
buffer.append("\n");
}
} catch (Exception e) {
e.printStackTrace();
}

return buffer.toString();
}
} catch (CertificateException e) {
e.printStackTrace();
throw new CertificateException(e);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
throw new CertificateException(e);
} catch (KeyManagementException e) {
e.printStackTrace();
throw new CertificateException(e);
} catch (NoSuchProviderException e) {
e.printStackTrace();
throw new CertificateException(e);

} catch (KeyStoreException e){
e.printStackTrace();
throw new CertificateException(e);
}catch(Exception e){
e.printStackTrace();
throw new Exception(e);
}