HTTPS全面解析

最新推荐文章于 2024-10-02 09:17:55 发布
最新推荐文章于 2024-10-02 09:17:55 发布
阅读量9.2k 收藏 1
点赞数
分类专栏： Android 文章标签： https 双向认证 SSL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_286/article/details/55195272
版权
百度百科对https的介绍：
HTTPS（全称：Hyper Text Transfer Protocol over Secure Socket Layer），是以安全为目标的HTTP通道，简单讲是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。 它是一个URI scheme（抽象标识符体系），句法类同http:体系。用于安全的HTTP数据传输。https:URL表明它使用了HTTP，但HTTPS存在不同于HTTP的默认端口及一个加密/身份验证层（在HTTP与TCP之间）。
HTTPS和HTTP的区别主要为以下四点：
一、https协议需要到ca申请证书，一般免费证书很少，需要交费。
二、http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议。
三、http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
四、http的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。
握手过程
为了便于更好的认识和理解SSL 协议，这里着重介绍SSL 协议的握手协议。SSL 协议既用到了公钥加密技术又用到了对称加密技术，对称加密技术虽然比公钥加密技术的速度快，可是公钥加密技术提供了更好的身份认证技术。SSL 的握手协议非常有效的让客户和服务器之间完成相互之间的身份认证，其主要过程如下：
①客户端的浏览器向服务器传送客户端SSL 协议的版本号，加密算法的种类，产生的随机数，以及其他服务器和客户端之间通讯所需要的各种信息。
②服务器向客户端传送SSL 协议的版本号，加密算法的种类，随机数以及其他相关信息，同时服务器还将向客户端传送自己的证书。
③客户利用服务器传过来的信息验证服务器的合法性，服务器的合法性包括：证书是否过期，发行服务器证书的CA 是否可靠，发行者证书的公钥能否正确解开服务器证书的“发行者的数字签名”，服务器证书上的域名是否和服务器的实际域名相匹配。如果合法性验证没有通过，通讯将断开；如果合法性验证通过，将继续进行第四步。
④用户端随机产生一个用于后面通讯的“对称密码”，然后用服务器的公钥（服务器的公钥从步骤②中的服务器的证书中获得）对其加密，然后将加密后的“预主密码”传给服务器。
⑤如果服务器要求客户的身份认证（在握手过程中为可选），用户可以建立一个随机数然后对其进行数据签名，将这个含有签名的随机数和客户自己的证书以及加密过的“预主密码”一起传给服务器。
⑥如果服务器要求客户的身份认证，服务器必须检验客户证书和签名随机数的合法性，具体的合法性验证过程包括：客户的证书使用日期是否有效，为客户提供证书的CA 是否可靠，发行CA 的公钥能否正确解开客户证书的发行CA 的数字签名，检查客户的证书是否在证书废止列表（CRL）中。检验如果没有通过，通讯立刻中断；如果验证通过，服务器将用自己的私钥解开加密的“预主密码”，然后执行一系列步骤来产生主通讯密码（客户端也将通过同样的方法产生相同的主通讯密码）。
⑦服务器和客户端用相同的主密码即“通话密码”，一个对称密钥用于SSL 协议的安全数据通讯的加解密通讯。同时在SSL 通讯过程中还要完成数据通讯的完整性，防止数据通讯中的任何变化。
⑧客户端向服务器端发出信息，指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥，同时通知服务器客户端的握手过程结束。
⑨服务器向客户端发出信息，指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥，同时通知客户端服务器端的握手过程结束。

⑩SSL 的握手部分结束，SSL 安全通道的数据通讯开始，客户和服务器开始使用相同的对称密钥进行数据通讯，同时进行通讯完整性的检验。

下面我们就来写一下Https请求

String path = "https://www.baidu.com";
URL url = new URL(path);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
InputStream is = conn.getInputStream();
String string = Utils.inputStream2String(is);
System.out.println(string);
这个可以正常访问，它就会将百度的html返回回来，那下面我们就url改成其他的看看，将其改成我tomcat下的一个工程网址（已放开了https配置，设置了自签名证书）：https://localhost:8443/Test/myTest 

String path = "https://localhost:8443/Test/myTest";
URL url = new URL(path);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
InputStream is = conn.getInputStream();
String string = Utils.inputStream2String(is);
System.out.println(string);
这时就访问不了了，报了一个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错误
那么这是为什么了呢，百度的https就可以访问，而自己tomcat的https就不可以访问呢？咱再来看一看百度百科
信任主机的问题
采用https的服务器必须从CA （Certificate Authority）申请一个用于证明服务器用途类型的证书。该证书只有用于对应的服务器的时候，客户端才信任此主机。所以所有的银行系统网站，关键部分应用都是https 的。客户通过信任该证书，从而信任了该主机。其实这样做效率很低，但是银行更侧重安全。
原来只有从CA机构申请的证书默认情况是受信任的，客户端可以直接访问。而我自己tomcat下的证书是使用java下的keytool工具自动生成的，并不是CA机构颁发的，所以默认是不受信任的。那么我们如何处理，使其受信任并且可以访问呢？有两种方式：1.无条件的设置信任所有的证书。2.设置只信任与服务器设置的jks对应的cer证书

1.无条件的设置信任所有的证书，但是这样做是不安全的

public static void main(String[] args) {
	try {
	//初始化SSLContext
	SSLContext context = SSLContext.getInstance("TLS");//TLS和SSL都可以
	//设置信任管理器
	TrustManager[] managers = new TrustManager[]{new EmptyTrustManager()};
	context.init(null, managers, null);
	//这个必须在HttpsURLConnection生成对象之前设置
	HttpsURLConnection.setDefaultSSLSocketFactory(context.getSocketFactory());
			
	String path = "https://localhost:8443/Test/myTest";
	URL url = new URL(path);
	HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
	//这时设置SSLSocketFactory没有用
	//conn.setDefaultSSLSocketFactory(conn.getSSLSocketFactory());
	InputStream is = conn.getInputStream();
	String string = Utils.inputStream2String(is);
	System.out.println(string);
	} catch (Exception e) {
		e.printStackTrace();
	}
}

static class EmptyTrustManager implements X509TrustManager {

	@Override
	public void checkClientTrusted(X509Certificate[] chain, String authType)
			throws CertificateException {

	}

	@Override
	public void checkServerTrusted(X509Certificate[] chain, String authType)
			throws CertificateException {

	}

	@Override
	public X509Certificate[] getAcceptedIssuers() {
		return null;
	}

}
2.设置只信任与服务器设置的jks对应的cer证书。当你将自己的项目的网络请求改为https时，后台哥们会给你一个xxx.cer证书，这个证书就会和后台的xxx.jks进行验证校验。我们可以将xxx.cer放到工程中，去读取文件，也可以将其打印成字符串，将字符串放到代码中去读取。以下我是以字符串的形式使用的 

static String chen = "-----BEGIN CERTIFICATE-----\n"+
			"MIIDWTCCAkGgAwIBAgIENIaROTANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJDTjENMAsGA1UE"+
			"CBMEY2hlbjENMAsGA1UEBxMEY2hlbjENMAsGA1UEChMEY2hlbjENMAsGA1UECxMEY2hlbjESMBAG"+
			"A1UEAxMJbG9jYWxob3N0MB4XDTE3MDIxMzA5NDIzN1oXDTI2MTIyMzA5NDIzN1owXTELMAkGA1UE"+
			"BhMCQ04xDTALBgNVBAgTBGNoZW4xDTALBgNVBAcTBGNoZW4xDTALBgNVBAoTBGNoZW4xDTALBgNV"+
			"BAsTBGNoZW4xEjAQBgNVBAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC"+
			"ggEBAKolNf440rZx58iz5P58VrWWPMQDZPMYuDDeZMENHRIUOu+PmjKwpmJUqVnKMvyGFj9VtoPE"+
			"kZE7NQLzJ0FIfaTBLaHRTYLisk3qnVXgZyZq/rrLq935SURCRl76NP+pAyXBoWVUkvzRYwXfhFUi"+
			"zO5yjH+ZFfQzjGWCugd8oYCLKmP+pJnlP/faNu7YDjL9JkOm6KiEnmkklkSJXrBBxmpsy0lSShwY"+
			"rNoZ4wW8XwgbNdwjM+Z4+IeOD/gBZMSrI8n8TLKBFH6IydFJOkwhHO1BvdzNQHrcXF0CRqM5ctW4"+
			"K7LXXE8OJg59b28ghdiqVAWRnSEyIYNgEBLkXnaU95UCAwEAAaMhMB8wHQYDVR0OBBYEFDt5QPgy"+
			"T3yfkb9iXV92Wzo1YndfMA0GCSqGSIb3DQEBCwUAA4IBAQA9ZVQIGQERDvDlsjlSzmhcrX0Gpdxf"+
			"kFmgXEc+Tck04l2VaT70YXYztcWTm8iPlxAOTAjxRE0syIbbAQ4UPba0hFINCPpvCD31ax3ukFUj"+
			"NJH+rZUwo1HjV8qzKAA4nd3f31PRg3yyAzmgfAwqVNxiq26YVglvV6h3TnC6dgcnV4sejOvv5nTA"+
			"7qc0cbQvGIEz4bEwIc+0l2/gwIoeUIquM6OAQTVzX9LuJ1aUTpenut+9G+vkEO3pfy4gdnOOXntW"+
			"uzqhaUV9gxOd1et10n1pvDcYNG6hhAkvotgV8Pl+NnDZ22Hqin1XB1cOZv18zHxC9WThRma3VN0V"+
			"z08eItRz\n"+
			"-----END CERTIFICATE-----";

	public static void main(String[] args) {
		try {
			ByteArrayInputStream baos = new ByteArrayInputStream(chen.getBytes());
			SSLContext sslContext = getSSLContext(baos);
			HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
			
			String path = "https://localhost:8443/Test/myTest";
			URL url = new URL(path);
			HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
			//conn.setDefaultSSLSocketFactory(conn.getSSLSocketFactory());
			InputStream is = conn.getInputStream();
			String string = Utils.inputStream2String(is);
			System.out.println(string);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	static SSLContext getSSLContext(InputStream is){
		try{
			//初始化SSLContext
			SSLContext context = SSLContext.getInstance("TLS");//TLS和SSL都可以
			// 1.导入证书
			Certificate certificate = CertificateFactory.getInstance("X.509")
					.generateCertificate(is);
			// 2.证书导入密钥库
			KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
			keyStore.load(null);
			keyStore.setCertificateEntry("srca", certificate);
			// 3.把密钥库放入信任管理器
			TrustManagerFactory trustManagerFactory = TrustManagerFactory
					.getInstance(TrustManagerFactory.getDefaultAlgorithm());
			trustManagerFactory.init(keyStore);
			// 4.生成信任管理器
			TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();
			// 将信任管理器设置到SSLContext
			context.init(null, trustManagers, null);
			
			return context;
		}catch(Exception e){
			e.printStackTrace();
		}
		return null;
	}
如果url中的Hostname用的是IP则情况就不一样了，如果是String path = "https://127.0.0.1:8443/Test/myTest";再次访问的时候，会报javax.net.ssl.SSLHandshakeException: java.security.cert.CertificateException: No subject alternative names present错误。
所以在HttpsURLConnection中的默认主机名验证的方法中应返回true以表示通过， 

HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
				
				@Override
				public boolean verify(String hostname, SSLSession session) {
					
					return true;
				}
			});
此设置应和SSLSocketFactory一样，在生成HttpsURLConnection之前设置，不然无效，所以main方法中代码应为 

public static void main(String[] args) {
		try {
			ByteArrayInputStream baos = new ByteArrayInputStream(chen.getBytes());
			SSLContext sslContext = getSSLContext(baos);
			HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
			HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
				
				@Override
				public boolean verify(String hostname, SSLSession session) {
					
					return true;
				}
			});
			
			String path = "https://127.0.0.1:8443/Test/myTest";
			URL url = new URL(path);
			HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
			//conn.setDefaultSSLSocketFactory(conn.getSSLSocketFactory());
			InputStream is = conn.getInputStream();
			String string = Utils.inputStream2String(is);
			System.out.println(string);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

这时就可以正常访问了。
服务器端配置https

下面我们就来讲解如何生成自签名证书，和tomcat如何部署，完成这两步tomcat就可以使用https访问了，首先我们使用java自带的keytool工具生成证书，win+R打开运行，输入cmd打开cmd命令窗体，按照如下方式输入：

如何生成https证书:

1.生成jks，使用如下的命令就会生成一个chen.jks，密码为123456，jks是服务端tomcat配置https时使用的证书

C:\Program Files\Java\jdk1.7.0_67\bin>keytool -genkey -alias chen -keyalg
 RSA -keystore C:\CJ\chen.jks -validity 3600 -storepass 123456
您的名字与姓氏是什么?
  [Unknown]:  localhost
您的组织单位名称是什么?
  [Unknown]:  chen
您的组织名称是什么?
  [Unknown]:  chen
您所在的城市或区域名称是什么?
  [Unknown]:  chen
您所在的省/市/自治区名称是什么?
  [Unknown]:  chen
该单位的双字母国家/地区代码是什么?
  [Unknown]:  CN
CN=localhost, OU=chen, O=chen, L=chen, ST=chen, C=CN是否正确?
  [否]:  y

输入 <chen_client> 的密钥口令
        (如果和密钥库口令相同, 按回车):
再次输入新口令:
2.生成cer，使用如下命令和chen.jks就会生成一个chen.cer，xxx.cer是客户端https访问时用于与服务端jks进行校验的 

C:\Program Files\Java\jdk1.7.0_67\bin>keytool -export -alias chen -file C
:\CJ\chen.cer -keystore C:\CJ\chen.jks -storepass 123456
存储在文件 <C:\CJ\chen_client.cer> 中的证书
3.打印cer，使用如下命令就可以打印cer中的字符串，就是上述提到的将cer打印成字符串，放入代码中，就不需要将xxx.cer放到工程中了。 
C:\Program Files\Java\jdk1.7.0_67\bin>keytool -printcert -rfc -file C:\CJ\chen.cer
-----BEGIN CERTIFICATE-----
MIIDWTCCAkGgAwIBAgIENIaROTANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJDTjENMAsGA1UE
CBMEY2hlbjENMAsGA1UEBxMEY2hlbjENMAsGA1UEChMEY2hlbjENMAsGA1UECxMEY2hlbjESMBAG
A1UEAxMJbG9jYWxob3N0MB4XDTE3MDIxMzA5NDIzN1oXDTI2MTIyMzA5NDIzN1owXTELMAkGA1UE
BhMCQ04xDTALBgNVBAgTBGNoZW4xDTALBgNVBAcTBGNoZW4xDTALBgNVBAoTBGNoZW4xDTALBgNV
BAsTBGNoZW4xEjAQBgNVBAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
ggEBAKolNf440rZx58iz5P58VrWWPMQDZPMYuDDeZMENHRIUOu+PmjKwpmJUqVnKMvyGFj9VtoPE
kZE7NQLzJ0FIfaTBLaHRTYLisk3qnVXgZyZq/rrLq935SURCRl76NP+pAyXBoWVUkvzRYwXfhFUi
zO5yjH+ZFfQzjGWCugd8oYCLKmP+pJnlP/faNu7YDjL9JkOm6KiEnmkklkSJXrBBxmpsy0lSShwY
rNoZ4wW8XwgbNdwjM+Z4+IeOD/gBZMSrI8n8TLKBFH6IydFJOkwhHO1BvdzNQHrcXF0CRqM5ctW4
K7LXXE8OJg59b28ghdiqVAWRnSEyIYNgEBLkXnaU95UCAwEAAaMhMB8wHQYDVR0OBBYEFDt5QPgy
T3yfkb9iXV92Wzo1YndfMA0GCSqGSIb3DQEBCwUAA4IBAQA9ZVQIGQERDvDlsjlSzmhcrX0Gpdxf
kFmgXEc+Tck04l2VaT70YXYztcWTm8iPlxAOTAjxRE0syIbbAQ4UPba0hFINCPpvCD31ax3ukFUj
NJH+rZUwo1HjV8qzKAA4nd3f31PRg3yyAzmgfAwqVNxiq26YVglvV6h3TnC6dgcnV4sejOvv5nTA
7qc0cbQvGIEz4bEwIc+0l2/gwIoeUIquM6OAQTVzX9LuJ1aUTpenut+9G+vkEO3pfy4gdnOOXntW
uzqhaUV9gxOd1et10n1pvDcYNG6hhAkvotgV8Pl+NnDZ22Hqin1XB1cOZv18zHxC9WThRma3VN0V
z08eItRz
-----END CERTIFICATE-----
4.tomcat服务器配置 ,在tomcat下的conf文件夹下的server.xml中配置 

<Connector SSLEnabled="true" acceptCount="100" clientAuth="false" 
		disableUploadTimeout="true" enableLookups="true" keystoreFile="C:\\CJ\\chen.jks" keystorePass="123456" maxSpareThreads="75" 
		maxThreads="200" minSpareThreads="5" port="8443" 
		protocol="org.apache.coyote.http11.Http11NioProtocol" scheme="https" 
		secure="true" sslProtocol="TLS"
      />
在server.xml中的https默认配置的port为8443，你也可以修改，当你的电脑的8443端口被其他应用占用的时候，你就可以修改。这是重新启动tomcat时，这时你的服务器就可以使用https访问了。
这时该服务器用上面的网络请求就可以访问了。

双向证书验证
前面的https请求时，是服务器一个chen.jks,客户端一个chen.cer。那么双向证书验证，就还需要再次之前的配置上，再加上服务器一个chen_client.cer,客户端一个chen_client.jks。

重新生成一个证书
1.生成jks

C:\Program Files\Java\jdk1.7.0_67\bin>keytool -genkey -alias chen -keyalg
 RSA -keystore C:\CJ\chen.jks -validity 3600 -storepass 123456
您的名字与姓氏是什么?
  [Unknown]:  localhost
您的组织单位名称是什么?
  [Unknown]:  chen
您的组织名称是什么?
  [Unknown]:  chen
您所在的城市或区域名称是什么?
  [Unknown]:  chen
您所在的省/市/自治区名称是什么?
  [Unknown]:  chen
该单位的双字母国家/地区代码是什么?
  [Unknown]:  CN
CN=localhost, OU=chen, O=chen, L=chen, ST=chen, C=CN是否正确?
  [否]:  y

输入 <chen_client> 的密钥口令
        (如果和密钥库口令相同, 按回车):
再次输入新口令:
2.生成cer 

C:\Program Files\Java\jdk1.7.0_67\bin>keytool -export -alias chen -file C
:\CJ\chen.cer -keystore C:\CJ\chen.jks -storepass 123456
存储在文件 <C:\CJ\chen_client.cer> 中的证书
需要将cer证书添加到jks中，不然，如果服务端使用cer证书，会报一个Invalid keystore format错误 

C:\Program Files\Java\jdk1.7.0_67\bin>keytool -import -alias chen_client -file C
:\CJ\chen_client.cer -keystore C:\CJ\chen_client_for_server.jks
3.修改tomcat的配置文件

需要将之前的clientAuth="false"改为clientAuth="true",在增加一个字段truststoreFile="C:\\CJ\\chen_client_for_server.jks"，指明jks的路径。

<Connector SSLEnabled="true" acceptCount="100" clientAuth="true" 
		disableUploadTimeout="true" enableLookups="true" keystoreFile="C:\\CJ\\chen.jks" keystorePass="123456" maxSpareThreads="75" 
		maxThreads="200" minSpareThreads="5" port="8443" 
		protocol="org.apache.coyote.http11.Http11NioProtocol" scheme="https" 
		secure="true" sslProtocol="TLS"
		truststoreFile="C:\\CJ\\chen_client_for_server.jks" 
      />
当是双向证书验证验证时，如果在tomcat/conf/sever.xml文件中的配置属性clientAuth="false",没有将其改为true，这是的双向证书验证验依然是单向的，客户端不做任何修改，https依然可以访问，如果将其改为true，就访问不了了。
这时重启服务器时，之前的https网络请求就请求不了了，报java.net.SocketException: Software caused connection abort: recv failed。这时我们需要修改一下网络请求代码，context.init(null, trustManagers, null);第一个参数是KeyManager[]，是客户端的key，就是使用我们第二次生成的chen_client.jks，生成的KeyManager[]。添加如下代码： 
//初始化keystore
KeyStore clientKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
InputStream iStream = new FileInputStream("chen_client.jks");
clientKeyStore.load(iStream, "123456".toCharArray());
//将keystore放入密钥管理器
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
keyManagerFactory.init(clientKeyStore, "123456".toCharArray());
 //生成密钥管理器
KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();
// 将信任管理器设置到SSLContext
context.init(keyManagers, trustManagers, null);
这时就可以进行网络请求了（java平台），客户端和服务器就是双向证书验证方式，网络请求就会更加的安全可靠。（如果是双向证书验证的tomcat，如果客户端不给kayManagers就会报 javax.net.ssl.SSLException: Connection closed by peer 错误）
这时我们将代码移植到Android工程中，跑起来，访问网络失败，报java.io.IOException: Wrong version of key store.异常。这是因为Java平台默认识别jks格式的证书文件，但是android平台只识别bks格式的证书文件。所以这时我们就需要将jks格式转成bks格式，我们可以使用Portecle工具进行转换： 下载。下载完之后解压，里面有一个Portecle.jar,在DOS界面，使用jave -jar Portecle.jar打开图形界面，操作步骤：1.File->Open Keystore File->选择chen_client.jks->输入密码 2.Tools->Change Keystore Type->BKS->输入密码 3.Save Keystore->选择保存路径（命名：chen_client.bks）。然后将Android工程中的chen_client.jks替换为chen_client.bks。重新运行Android项目，就可以正常访问了。Android中的完整代码如下：

URLConnection双向证书验证的https请求：

import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import com.tydz.taoyuan.R;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.security.KeyStore;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;

public class HttpsActivity extends AppCompatActivity {

    static Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mTextView.setText(msg.obj.toString());
        }
    };

    static String chen = "-----BEGIN CERTIFICATE-----\n" +
            "MIIDWTCCAkGgAwIBAgIEcWnCMTANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJDTjENMAsGA1UE\n" +
            "CBMEY2hlbjENMAsGA1UEBxMEY2hlbjENMAsGA1UEChMEY2hlbjENMAsGA1UECxMEY2hlbjESMBAG\n" +
            "A1UEAxMJbG9jYWxob3N0MB4XDTE3MDIxMzE0MTIzNVoXDTI2MTIyMzE0MTIzNVowXTELMAkGA1UE\n" +
            "BhMCQ04xDTALBgNVBAgTBGNoZW4xDTALBgNVBAcTBGNoZW4xDTALBgNVBAoTBGNoZW4xDTALBgNV\n" +
            "BAsTBGNoZW4xEjAQBgNVBAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" +
            "ggEBAOCj9+qaE/DcDtJnEpeSc0+byTO3/yM673C4sgax7n4lCnjtmhgqiwASTCOnEMRJ6llmo/M8\n" +
            "+msz9i+1vE4lte7AkZ/3Wfu04BXq9wmDlVNWU3kU6TfZMUhqifTvRC6zQmfJaBdS6SSfmBslrUUC\n" +
            "ntD19vvGRLPkEt05s0itG54ex41fSgA4pBtj6qpBjLMS/03fCD6y3YdL+r0dN6bDxAuLo+2flJEy\n" +
            "9CrnXEzLcZ172zD+5mfvhFI7F1fF1kdjT4pNi22sap5AOFZazaK7snq03cLTchC7yBwcPCJ6IqzY\n" +
            "Yw6bVb79cj6nntbTb6lsrL7wv2kR8ubtiRTrrtCP2YMCAwEAAaMhMB8wHQYDVR0OBBYEFF5ZFY02\n" +
            "FejgLSsO9DOZppwUhGS4MA0GCSqGSIb3DQEBCwUAA4IBAQCNg76X3tRCtnDi7cT5M8ADMzSUlYvA\n" +
            "CaVYKQ+lB3WBLuqR3wVVJ/zeSGqiR4F59cj6Oij+fk5Fu05n+0nXX/sdirf2RTW1eaA+SzPYXdgA\n" +
            "0u8XJdaPu58q0GCPFpUv24ljzQEr/hZBS9HWlHmkgByecpgrrToOc3jJNIQr8g1NVO/b8RCBFyx8\n" +
            "Ax+Ytp8XNGKbmMnXifBxBnhMCT0DptmZuYsTacZ5qLqEhszChYSM3drYhoNId1HlLLeQbUumbB/8\n" +
            "N1BVVH2LYPTJgKdXTQAzTWiUAss/HD78fe30qI3MDrZ1h4eF+vCHqOwAOiLxQ0Rpb5oMsVCblmoR\n" +
            "+ool1ljG\n" +
            "-----END CERTIFICATE-----";
    private static TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_https);

        mTextView = (TextView) findViewById(R.id.textview);

        new Thread(){
            @Override
            public void run() {
                super.run();
                try {
                    net();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    private void net() throws Exception{

        ByteArrayInputStream baos = new ByteArrayInputStream(chen.getBytes());
        //InputStream iStream = new FileInputStream("chen_client.jks");
        InputStream iStream = getAssets().open("chen_client.bks");
        SSLContext sslContext = getSSLContext(baos,iStream);
        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {

            @Override
            public boolean verify(String hostname, SSLSession session) {

                return true;
            }
        });

        String path = "https://10.0.2.2:8444/OkHttp/text";
        URL url = new URL(path);
        HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();

        //********************************
        //POST请求
        /*
        conn.addRequestProperty("Content-Type", "application/json");
        conn.addRequestProperty("Connection", "Keep-Alive");// 维持长连接
        conn.addRequestProperty("Charset", "UTF-8");

        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.setUseCaches(false);
        conn.setRequestMethod("POST");

        OutputStream outputStream = conn.getOutputStream();
        outputStream.write("{\"name\":chen}".getBytes("UTF-8"));
        outputStream.flush();
        outputStream.close();
        */
        //************************************

        //conn.setDefaultSSLSocketFactory(conn.getSSLSocketFactory());
        InputStream is = conn.getInputStream();
        String string = inputStream2String(is);
        System.out.println(string);

        sendMsg(string);

    }

    private void sendMsg(String msg){
        Message message = mHandler.obtainMessage();
        message.obj = msg;
        mHandler.sendMessage(message);
    }

    SSLContext getSSLContext(InputStream cer,InputStream bks){
        try{
            //初始化SSLContext
            SSLContext context = SSLContext.getInstance("TLS");//TLS和SSL都可以
            // 1.导入证书
            Certificate certificate = CertificateFactory.getInstance("X.509")
                    .generateCertificate(cer);
            // 2.证书导入密钥库
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null);
            keyStore.setCertificateEntry("srca", certificate);
            // 3.把密钥库放入信任管理器
            TrustManagerFactory trustManagerFactory = TrustManagerFactory
                    .getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keyStore);
            // 4.生成信任管理器
            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

            //初始化keystore
            KeyStore clientKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            clientKeyStore.load(bks, "123456".toCharArray());
            //将keystore放入密钥管理器
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(clientKeyStore, "123456".toCharArray());
            //生成密钥管理器
            KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();
            // 将信任管理器设置到SSLContext
            context.init(keyManagers, trustManagers, null);

            return context;
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }

    public static String inputStream2String(InputStream in) throws IOException {
        int len = -1;
        byte[] buffer = new byte[1024];
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        while ((len = in.read(buffer)) != -1) {
            baos.write(buffer, 0, len);
        }
        baos.close();

        return baos.toString("UTF-8");
    }
}
Volley双向证书验证的https请求：
Volley因为API>=9底层的就是用HttpsURLConnection,HttpsURLConnection实现的，所以volley实现https的代码可以参考java的HttpsURLConnection的，volley的http请求时的请求队列：RequestQueue queue = Volley.newRequestQueue(getApplication());，newRequestQueue(Context)还有一个重载方法newRequestQueue(Context context, HttpStack stack)，这个就是https的入口，HurlStack构造中就有一个参数传的就是SSLSocketFactory，所以volley的https的请求代码如下： 

import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.TextView;

import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HurlStack;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;

public class MainActivity extends AppCompatActivity {

    static Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mTextView.setText(msg.obj.toString());
        }
    };


    static String chen = "-----BEGIN CERTIFICATE-----\n" +
            "MIIDWTCCAkGgAwIBAgIEcWnCMTANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJDTjENMAsGA1UE\n" +
            "CBMEY2hlbjENMAsGA1UEBxMEY2hlbjENMAsGA1UEChMEY2hlbjENMAsGA1UECxMEY2hlbjESMBAG\n" +
            "A1UEAxMJbG9jYWxob3N0MB4XDTE3MDIxMzE0MTIzNVoXDTI2MTIyMzE0MTIzNVowXTELMAkGA1UE\n" +
            "BhMCQ04xDTALBgNVBAgTBGNoZW4xDTALBgNVBAcTBGNoZW4xDTALBgNVBAoTBGNoZW4xDTALBgNV\n" +
            "BAsTBGNoZW4xEjAQBgNVBAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" +
            "ggEBAOCj9+qaE/DcDtJnEpeSc0+byTO3/yM673C4sgax7n4lCnjtmhgqiwASTCOnEMRJ6llmo/M8\n" +
            "+msz9i+1vE4lte7AkZ/3Wfu04BXq9wmDlVNWU3kU6TfZMUhqifTvRC6zQmfJaBdS6SSfmBslrUUC\n" +
            "ntD19vvGRLPkEt05s0itG54ex41fSgA4pBtj6qpBjLMS/03fCD6y3YdL+r0dN6bDxAuLo+2flJEy\n" +
            "9CrnXEzLcZ172zD+5mfvhFI7F1fF1kdjT4pNi22sap5AOFZazaK7snq03cLTchC7yBwcPCJ6IqzY\n" +
            "Yw6bVb79cj6nntbTb6lsrL7wv2kR8ubtiRTrrtCP2YMCAwEAAaMhMB8wHQYDVR0OBBYEFF5ZFY02\n" +
            "FejgLSsO9DOZppwUhGS4MA0GCSqGSIb3DQEBCwUAA4IBAQCNg76X3tRCtnDi7cT5M8ADMzSUlYvA\n" +
            "CaVYKQ+lB3WBLuqR3wVVJ/zeSGqiR4F59cj6Oij+fk5Fu05n+0nXX/sdirf2RTW1eaA+SzPYXdgA\n" +
            "0u8XJdaPu58q0GCPFpUv24ljzQEr/hZBS9HWlHmkgByecpgrrToOc3jJNIQr8g1NVO/b8RCBFyx8\n" +
            "Ax+Ytp8XNGKbmMnXifBxBnhMCT0DptmZuYsTacZ5qLqEhszChYSM3drYhoNId1HlLLeQbUumbB/8\n" +
            "N1BVVH2LYPTJgKdXTQAzTWiUAss/HD78fe30qI3MDrZ1h4eF+vCHqOwAOiLxQ0Rpb5oMsVCblmoR\n" +
            "+ool1ljG\n" +
            "-----END CERTIFICATE-----";
    private static TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mTextView = (TextView) findViewById(R.id.textview);

    }

    public void click(View view){
        new Thread(){
            @Override
            public void run() {
                super.run();
                try {
                    volley();

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }


    void volley() throws Exception{
        String path = "https://10.0.2.2:8444/OkHttp/text";
        ByteArrayInputStream baos = new ByteArrayInputStream(chen.getBytes());
        //InputStream iStream = new FileInputStream("chen_client.jks");
        InputStream iStream = getAssets().open("chen_client.bks");
        SSLContext sslContext = getSSLContext(baos,iStream);
        //SSLSocketFactory在HurlStack内部已经实现
        //HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());
        HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {

            @Override
            public boolean verify(String hostname, SSLSession session) {

                return true;
            }
        });
        HurlStack hurlStack = new HurlStack(null,sslContext.getSocketFactory());
        RequestQueue queue = Volley.newRequestQueue(getApplication(),hurlStack);
        //get
        StringRequest request = new StringRequest(path, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                sendMsg(response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                error.printStackTrace();
                sendMsg(error.toString());
            }
        });
        //post
	/*
	Map map = new HashMap<>();
        map.put("userName", "183********");
        map.put("password", "111111");
        JSONObject object = new JSONObject(map);

        JsonObjectRequest request = new JsonObjectRequest(Request.Method.POST, path, object, new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                sendMsg(response.toString());
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                error.printStackTrace();
                sendMsg(error.toString());
            }
        });
	*/
        queue.add(request);
    }


    private void sendMsg(String msg){
        Message message = mHandler.obtainMessage();
        message.obj = msg;
        mHandler.sendMessage(message);
    }

    SSLContext getSSLContext(InputStream cer,InputStream bks){
        try{
            //初始化SSLContext
            SSLContext context = SSLContext.getInstance("TLS");//TLS和SSL都可以
            // 1.导入证书
            Certificate certificate = CertificateFactory.getInstance("X.509")
                    .generateCertificate(cer);
            // 2.证书导入密钥库
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null);
            keyStore.setCertificateEntry("srca", certificate);
            // 3.把密钥库放入信任管理器
            TrustManagerFactory trustManagerFactory = TrustManagerFactory
                    .getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keyStore);
            // 4.生成信任管理器
            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

            //初始化keystore
            KeyStore clientKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            clientKeyStore.load(bks, "123456".toCharArray());
            //将keystore放入密钥管理器
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(clientKeyStore, "123456".toCharArray());
            //生成密钥管理器
            KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();
            // 将信任管理器设置到SSLContext
            context.init(keyManagers, trustManagers, new SecureRandom());

            return context;
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }

}

OkHttp双向证书验证的https请求： 

import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.LinearLayout;
import android.widget.TextView;

import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HurlStack;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;

import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;

public class MainActivity extends AppCompatActivity {

    static Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            mTextView.setText(msg.obj.toString());
        }
    };

    static String chen = "-----BEGIN CERTIFICATE-----\n" +
            "MIIDWTCCAkGgAwIBAgIEcWnCMTANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJDTjENMAsGA1UE\n" +
            "CBMEY2hlbjENMAsGA1UEBxMEY2hlbjENMAsGA1UEChMEY2hlbjENMAsGA1UECxMEY2hlbjESMBAG\n" +
            "A1UEAxMJbG9jYWxob3N0MB4XDTE3MDIxMzE0MTIzNVoXDTI2MTIyMzE0MTIzNVowXTELMAkGA1UE\n" +
            "BhMCQ04xDTALBgNVBAgTBGNoZW4xDTALBgNVBAcTBGNoZW4xDTALBgNVBAoTBGNoZW4xDTALBgNV\n" +
            "BAsTBGNoZW4xEjAQBgNVBAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC\n" +
            "ggEBAOCj9+qaE/DcDtJnEpeSc0+byTO3/yM673C4sgax7n4lCnjtmhgqiwASTCOnEMRJ6llmo/M8\n" +
            "+msz9i+1vE4lte7AkZ/3Wfu04BXq9wmDlVNWU3kU6TfZMUhqifTvRC6zQmfJaBdS6SSfmBslrUUC\n" +
            "ntD19vvGRLPkEt05s0itG54ex41fSgA4pBtj6qpBjLMS/03fCD6y3YdL+r0dN6bDxAuLo+2flJEy\n" +
            "9CrnXEzLcZ172zD+5mfvhFI7F1fF1kdjT4pNi22sap5AOFZazaK7snq03cLTchC7yBwcPCJ6IqzY\n" +
            "Yw6bVb79cj6nntbTb6lsrL7wv2kR8ubtiRTrrtCP2YMCAwEAAaMhMB8wHQYDVR0OBBYEFF5ZFY02\n" +
            "FejgLSsO9DOZppwUhGS4MA0GCSqGSIb3DQEBCwUAA4IBAQCNg76X3tRCtnDi7cT5M8ADMzSUlYvA\n" +
            "CaVYKQ+lB3WBLuqR3wVVJ/zeSGqiR4F59cj6Oij+fk5Fu05n+0nXX/sdirf2RTW1eaA+SzPYXdgA\n" +
            "0u8XJdaPu58q0GCPFpUv24ljzQEr/hZBS9HWlHmkgByecpgrrToOc3jJNIQr8g1NVO/b8RCBFyx8\n" +
            "Ax+Ytp8XNGKbmMnXifBxBnhMCT0DptmZuYsTacZ5qLqEhszChYSM3drYhoNId1HlLLeQbUumbB/8\n" +
            "N1BVVH2LYPTJgKdXTQAzTWiUAss/HD78fe30qI3MDrZ1h4eF+vCHqOwAOiLxQ0Rpb5oMsVCblmoR\n" +
            "+ool1ljG\n" +
            "-----END CERTIFICATE-----";
    private static TextView mTextView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = (TextView) findViewById(R.id.textview);

    }

    public void click(View view){
        new Thread(){
            @Override
            public void run() {
                super.run();
                try {
                    okhttp();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    void okhttp() throws Exception{
        String path = "https://10.0.2.2:8444/OkHttp/text";
        ByteArrayInputStream baos = new ByteArrayInputStream(chen.getBytes());
        //InputStream iStream = new FileInputStream("chen_client.jks");
        InputStream iStream = getAssets().open("chen_client.bks");
        SSLManagerParams ssl = getSSLManagerParams(baos,iStream);
        OkHttpClient client = new OkHttpClient.Builder()
                .sslSocketFactory(ssl.mFactory,ssl.mTrustManager)
                .hostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String s, SSLSession sslSession) {
                        return true;
                    }
                })
                .build();
	//get
        Request request = new Request.Builder().get().url(path).build();
	//post
	/*
	Map<String,String> map = new HashMap<>();
        map.put("userName", "183********");
        map.put("password", "111111");
        JSONObject jsonObject = new JSONObject(map);
        RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"),jsonObject.toString());
        okhttp3.Request request = new okhttp3.Request.Builder().post(requestBody).url(path).build();
	*/
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
                sendMsg(e.toString());
            }

            @Override
            public void onResponse(Call call, okhttp3.Response response) throws IOException {
                sendMsg(response.body().string());
            }
        });
    }


    private void sendMsg(String msg){
        Message message = mHandler.obtainMessage();
        message.obj = msg;
        mHandler.sendMessage(message);
    }


    static class SSLManagerParams{
        public SSLSocketFactory mFactory;
        public X509TrustManager mTrustManager;
    }

    SSLManagerParams getSSLManagerParams(InputStream cer,InputStream bks){
        SSLManagerParams ssl = new SSLManagerParams();
        try{
            //初始化SSLContext
            SSLContext context = SSLContext.getInstance("TLS");//TLS和SSL都可以
            // 1.导入证书
            Certificate certificate = CertificateFactory.getInstance("X.509")
                    .generateCertificate(cer);
            // 2.证书导入密钥库
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            keyStore.load(null);
            keyStore.setCertificateEntry("srca", certificate);
            // 3.把密钥库放入信任管理器
            TrustManagerFactory trustManagerFactory = TrustManagerFactory
                    .getInstance(TrustManagerFactory.getDefaultAlgorithm());
            trustManagerFactory.init(keyStore);
            // 4.生成信任管理器
            TrustManager[] trustManagers = trustManagerFactory.getTrustManagers();

            //初始化keystore
            KeyStore clientKeyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            clientKeyStore.load(bks, "123456".toCharArray());
            //将keystore放入密钥管理器
            KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
            keyManagerFactory.init(clientKeyStore, "123456".toCharArray());
            //生成密钥管理器
            KeyManager[] keyManagers = keyManagerFactory.getKeyManagers();
            // 将信任管理器设置到SSLContext
            context.init(keyManagers, trustManagers, new SecureRandom());

            ssl.mFactory = context.getSocketFactory();
            ssl.mTrustManager = chooseX509TrustManager(trustManagers);

            return ssl;
        }catch(Exception e){
            e.printStackTrace();
        }
        return null;
    }

    private static X509TrustManager chooseX509TrustManager(TrustManager[] trustManagers)
    {
        for (TrustManager trustManager : trustManagers)
        {
            if (trustManager instanceof X509TrustManager)
            {
                return (X509TrustManager) trustManager;
            }
        }
        return null;
    }

}
好了，HPPTS全面解析到这里就结束了。以上的三种网络请求代码为了便于理解，并没有做合法性检测与封装，下面我提供了一个将三种https请求的简单封装工程。

下载：CSDN

参考：http://blog.csdn.net/lmj623565791/article/details/48129405



cj_286
关注
专栏目录
https的解析
李文_广的博客
09-20 824
文章目录0 SSL 与 TLS1 从网络协议的角度理解 HTTPS2 从密码学的角度理解 HTTPS2.1 TLS 工作流程2.2 密码基础2.2.1 伪随机数生成器2.2.2 消息认证码2.2.3 数字签名2.2.4 公钥密码2.2.5 证书2.2.6 密码小结2.3 TLS 使用的密码技术2.4 TLS 总结3 RSA 公钥秘钥算法简单示例4 参考 0 SSL 与 TLS SSL：（Secur...
计算机网络(六): HTTP,HTTPS,DNS,网页解析全过程
qq_43398345的博客
02-25 3459
服务端推送：服务器会在客户端没发起请求的时候主动推送一些需要的资源，比如客户端请求一个html文件，服务器发送完之后会把和这个html页面相关的静态文件也发送给客户端，当客户端准备向服务器请求静态文件的时候，就可以直接从缓存中获取，就不需要再发起请求了。410 表示所请求的资源已经被永久删除。header压缩：每次进行HTTP请求响应的时候，头部里很多的字段都是重复的，在2.0中，将字段记录到一张表中，头部只需要存放字段对应的编号就行，用的时候只需要拿着编号去表里查找就行，减少了传输的数据量。
https解析
qq_37152533的博客
11-07 402
本文主要是对HTTPS做一个总结，主要讲解HTTPS的实质、HTTPS加密原理、HTTPS的通信过程等。 1、HTTP存在问题: 由于HTTP协议过于简单： 通信使用明文（不加密），内容可能会被窃听。 不验证通信方的身份，因此可能遭遇伪装。 无法验证报文的完整性，所以有可能已遭篡改。 2、HTTPS的实质。 HTTP加上加密处理、认证机制、以及完整性保护后的就是HTTPS。 需要知道的是，HT...
万字图文详解HTTPS协议通信过程，结合抓包实战解析带你一次看透HTTPS！
所有成功的背后，都是痛苦的坚持，所有的痛苦，都是傻瓜般的不放弃!
09-26 2988
HTTPS 被称为 HTTP Over SSL (基于SSL加密的HTTP)，这里的SSL (Secure Socket Layer) 被称为安全套接层，它是一种加密协议，不仅可应用于HTTP协议、还可应用于POP3协议、SMTP协议、VPN等。TLS (Transport Layer Security) 被称为传输层安全，TLS相对于SSL 3.0版本做了些修改和功能增强，相当于SSL的升级版本，所以有时也一起统称为 SSL，接入来本文若不明显强调，SSL就默认表示SSL/TLS。我们可以用公式。
HTTPS解析
weixin_46120888的博客
12-26 3041
1.为啥要有HTTPS 我们原有的HTTP协议可以实现浏览器和服务器之间的交互，但是HTTP协议是明文传输十分不安全，一旦有不法分子偷偷篡改或者盗窃HTTP中的一些较为隐私的信息会造成非常严重的后果。HTTPS是加密的，就算拿到了也是密文 2.对称加密和非对称加密 2.1对称加密 特点：加密和解密使用相同的密钥，高效适合于大多数场景的加密，算法公开，安全性取决于密钥的大小，密钥越大效率越低。 缺点：算法本身安全，但是加密解密都用同一个密钥场景不安全。因为密钥会在传输中通过报文发送给服务器，服务器拿到之后会
分分钟让你理解HTTPS
weixin_33979363的博客
04-27 156
之前我有写过http相关的文章，在看本文前如果不了解http可以先看 《5分钟让你明白HTTP协议》。本文主要参考内容来自 用信鸽来解释 HTTPS 一、HTTP存在的问题 1.1 可能被窃听 HTTP 本身不具备加密的功能,HTTP 报文使用明文方式发送 由于互联网是由联通世界各个地方的网络设施组成,所有发送和接收经过某些设备的数据都可能被截获或窥视。(例如大家都熟悉的抓包工具:Wires...
解析百度搜索结果link?url=参数分析 (全)
10-27
然而，通过上述分析，我们可以看到尽管加密过程复杂，但并非无法解析。通过对加密字符串的结构分析和匹配，可以逐步揭示隐藏在加密链接背后的URL信息。这种技术挑战也是技术爱好者们乐于接受的，它推动了对网络协议...
wcf全面解析上册
01-11
**WCF全面解析** Windows Communication Foundation（WCF）是微软.NET框架中的一种核心服务导向架构，用于构建可互操作的企业级分布式应用程序。本资源“WCF全面解析上册”由蒋金楠精心制作，旨在帮助开发者从底层...
使用wireshark 抓取并解密https分析报告
07-16
### 使用Wireshark抓取并解密HTTPS分析报告 #### 实验工具 - 操作系统：Windows - Wireshark版本：2.2.1.0 #### 原理分析 ##### 2.1 HTTPS协议分析 HTTPS（Hypertext Transfer Protocol Secure）是一种安全的HTTP...
https请求解析
05-22
里面集成有许多httpclient方法，包括二进制流等一系列方法，囊括了我们大部分项目需要的。比较全面
HTTPS详细解析
热门推荐
苏南生的CSDN博客
11-20 1万+
1、 什么是HTTPS?HTTPS(Hyper Text Transfer Protocol over Secure Socket Layer)安全超文本传输协议，可以理解为HTTP+SSL/TLS，简单来说它是HTTP的安全版。HTTP 协议定义了一套规范，让客户端或浏览器可以和服务器正常通信，完成数据传输，但是HTTP协议采用明文传输信息，存在信息窃听、信息篡改和信息劫持的风险。TLS（Tra
https协议全解析
wuhuagu_wuhuaguo的博客
04-12 2467
一、HTTPS的实现原理 HTTPS 协议之所以是安全的是因为 HTTPS 协议会对传输的数据进行加密，而加密过程是使用了非对称加密实现。但其实，HTTPS 在内容传输的加密上使用的是对称加密，在证书验证阶段才使用了非对称加密。 ① 证书验证阶段 浏览器发起 HTTPS 请求 服务端返回 HTTPS 证书 ...
HTTP与HTTPS解析
Victor_psl的博客
02-16 522
一.HTTP简介: HTTP协议是超文本传输协议，详细规定了web服务器和浏览器之间通信的机制。他允许HTML超文本标记语言从web 服务器到浏览器传输。它是基于TCP/IP通信协议来传输数据。(支持HTML文本，图片查询等) 二.HTPP特点： 1.结构简单，是一种无状态的协议。不具备记忆功能， 2.属于短链接，客户端发送请求后，服务器响应请求后，断...
https协议是怎么进行加密的
最新发布
2202_76097976的博客
10-02 2081
在使用HTTP协议时，数据传输是明文形式，容易遭受运营商劫持等安全问题，如篡改返回网页内容、修改Referer字段等。为解决这些问题，引入了HTTPS协议，它通过加密、认证和完整性保护，确保通信内容不被第三方窃听或篡改。HTTPS结合了对称加密和非对称加密，使用公钥加密对称密钥，私钥解密，确保数据安全性和传输效率。然而，中间人攻击仍可能破解这一机制，因此引入证书机制，客户端通过验证证书中的数字签名来确认公钥的有效性，从而保障数据传输的安全性。
HTTPS原理解析
mymy1026的博客
02-18 345
HTTPS 一些概念 http 概述 HTTP是一个客户端(用户)和服务端(网站)之间请求和应答的标准，通常使用TCP协议。其本身位于TCP/IP协议族的应用层。 特点 - 客户端&服务器 - 无连接 - 无状态 密码学 对称秘钥算法 加密和解密时使用相同的密钥，或是使用两个可以简单地相互推算的密钥，常见算法有：AES、DES、SM4。 非对称秘钥算法 需要两个密...
Https工作原理解析
xiaohua688的博客
02-24 359
我们都知道HTTPS能够加密信息，以免敏感信息被第三方获取。所以很多银行网站或电子邮箱等等安全级别较高的服务都会采用HTTPS协议。HTTPS简介原文链接: http://www.cnblogs.com/zhuqil/archive/2012/07/23/2604572.htmlHTTPS其实是有两部分组成：HTTP + SSL / TLS，也就是在HTTP上又加了一层处理加密信息的模块。服务端和
HTTPS 解析
Erice_e的专栏
06-06 1580
因为这串密钥只有客户端和服务端知道，所以即使中间请求被拦截也是没法解密数据的，以此保证了通信的安全    非对称加密算法：RSA，DSA/DSS     在客户端与服务端相互验证的过程中用的是对称加密  对称加密算法：AES，RC4，3DES     客户端与服务端相互验证通过后，以随机数作为密钥时，就是对称加密 HASH算法：MD5，SHA1，SHA256  在确认握手消息没有被
HTTPS深度解析：权威指南与全面配置
本书旨在为Web开发人员、系统管理员以及所有对Web应用安全感兴趣的读者提供全面的指导，内容涵盖了丰富的理论知识、TLS协议详解、公钥基础设施(PKI)的安全性、HTTP和浏览器中的问题，以及关于协议漏洞如BEAST、CRIME...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值