一、背景
HTTP是一个传输内容有可读性的公开协定，客户端与服务器端的数据齐全通过明文传输。在这个背景之下，整个依赖于Http协定的互联网数据都是通明的，这带来了很大的数据安全隐患。想要解决这个问题有两个思路：
- C/S端各自负责，即客户端与服务端应用协商好的加密内容在Http上通信
- C/S端不负责加解密，加解密交给通信协议自身解决
第一种在事实中的利用范畴其实比设想中的要宽泛一些。单方线下替换密钥，客户端在发送的数据采纳的曾经是密文了，这个密文通过通明的Http协定在互联网上传输。服务端在接管到申请后，依照约定的形式解密取得明文。这种内容就算被劫持了也不要紧，因为第三方不晓得他们的加解密办法。然而这种做法太非凡了，客户端与服务端都须要关怀这个加解密非凡逻辑。
第二种C/S端能够不关怀下面的非凡逻辑，他们认为发送与接管的都是明文，因为加解密这一部分曾经被协定自身解决掉了。
从后果上看这两种计划仿佛没有什么区别，然而从软件工程师的角度看区别十分微小。因为第一种须要业务零碎本人开发响 应的加解密性能，并且线下要交互密钥，第二种没有开发量。
HTTPS是以后最风行的HTTP的平安模式，由NetScape公司独创。在HTTPS中，URL都是以https://结尾，而不是http://。应用了HTTPS时，所有的HTTP的申请与响应在发送到网络上之前都进行了加密，这是通过在SSL层实现的。
二、加密办法
通过SSL层对明文数据进行加密，而后放到互联网上传输，这解决了HTTP协定本来的数据安全性问题。一般来说，对数据加密的办法分为对称加密与非对称加密。
2.1 对称加密
对称加密是指加密与解密应用同样的密钥，常见的算法有DES与AES等，算法工夫与密钥长度相干。
对称密钥最大的毛病是须要保护大量的对称密钥，并且须要线下替换。退出一个网络中有n个实体，则须要n(n-1)个密钥。
2.2 非对称加密
非对称加密是指基于公私钥(public/private key)的加密办法，常见算法有RSA，一般而言加密速度慢于对称加密。
对称加密比非对称加密多了一个步骤，即要取得服务端公钥，而不是各自保护的密钥。
整个加密算法建设在肯定的数论根底上运算，达到的成果是，加密后果不可逆。即只有通过私钥(private key)能力解密失去经由公钥(public key)加密的密文。
在这种算法下，整个网络中的密钥数量大大降低，每个人只须要保护一对公司钥即可。即n个实体的网络中，密钥个数是2n。
其毛病是运行速度慢。
2.3 混合加密
周星驰电影《食神》中有一个场景，黑社会火并，争执撒尿虾与牛丸的底盘划分问题。食神说：“真是麻烦，掺在一起做成撒尿牛丸那，笨蛋！”
对称加密的长处是速度快，毛病是须要替换密钥。非对称加密的长处是不须要交互密钥，毛病是速度慢。罗唆掺在一起用好了。
混合加密正是HTTPS协定应用的加密形式。先通过非对称加密替换对称密钥，后通过对称密钥进行数据传输。
因为数据传输的量远远大于建设连贯初期替换密钥时应用非对称加密的数据量，所以非对称加密带来的性能影响根本能够疏忽，同时又进步了效率。
三、HTTPS握手
能够看到，在原HTTP协定的根底上，HTTPS退出了平安层解决：
- 客户端与服务端替换证书并验证身份，事实中服务端很少验证客户端的证书
- 协商加密协议的版本与算法，这里可能呈现版本不匹配导致失败
- 协商对称密钥，这个过程应用非对称加密进行
- 将HTTP发送的明文应用3中的密钥，2中的加密算法加密失去密文
- TCP层失常传输，对HTTPS无感知
四、HttpClient对HTTPS协定的反对
4.1 取得SSL连贯工厂以及域名校验器
作为一名软件工程师，咱们关怀的是“HTTPS协定”在代码上是怎么实现的呢？摸索HttpClient源码的神秘，所有都要从HttpClientBuilder开始。
public CloseableHttpClient build() {
//省略局部代码
HttpClientConnectionManager connManagerCopy = this.connManager;
//如果指定了连接池管理器则应用指定的，否则新建一个默认的
if (connManagerCopy == null) {
LayeredConnectionSocketFactory sslSocketFactoryCopy = this.sslSocketFactory;
if (sslSocketFactoryCopy == null) {
//如果开启了应用环境变量，https版本与明码控件从环境变量中读取
final String[] supportedProtocols = systemProperties ? split(
System.getProperty("https.protocols")) : null;
final String[] supportedCipherSuites = systemProperties ? split(
System.getProperty("https.cipherSuites")) : null;
//如果没有指定，应用默认的域名验证器，会依据ssl会话中服务端返回的证书来验证与域名是否匹配
HostnameVerifier hostnameVerifierCopy = this.hostnameVerifier;
if (hostnameVerifierCopy == null) {
hostnameVerifierCopy = new DefaultHostnameVerifier(publicSuffixMatcherCopy);
}
//如果制订了SslContext则生成定制的SSL连贯工厂，否则应用默认的连贯工厂
if (sslContext != null) {
sslSocketFactoryCopy = new SSLConnectionSocketFactory(
sslContext, supportedProtocols, supportedCipherSuites, hostnameVerifierCopy);
} else {
if (systemProperties) {
sslSocketFactoryCopy = new SSLConnectionSocketFactory(
(SSLSocketFactory) SSLSocketFactory.getDefault(),
supportedProtocols, supportedCipherSuites, hostnameVerifierCopy);
} else {
sslSocketFactoryCopy = new SSLConnectionSocketFactory(
SSLContexts.createDefault(),
hostnameVerifierCopy);
}
}
}
//将Ssl连贯工厂注册到连接池管理器中，当须要产生Https连贯的时候，会依据下面的SSL连贯工厂生产SSL连贯
@SuppressWarnings("resource")
final PoolingHttpClientConnectionManager poolingmgr = new PoolingHttpClientConnectionManager(
RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.getSocketFactory())
.register("https", sslSocketFactoryCopy)
.build(),
null,
null,
dnsResolver,
connTimeToLive,
connTimeToLiveTimeUnit != null ? connTimeToLiveTimeUnit : TimeUnit.MILLISECONDS);
//省略局部代码
}
}
下面的代码将一个Ssl连贯工厂SSLConnectionSocketFactory创立，并注册到了连接池管理器中，供之后生产Ssl连贯应用。连接池的问题参考：http://www.cnblogs.com/kingsz…
这里在配置SSLConnectionSocketFactory时用到了几个要害的组件，域名验证器HostnameVerifier以及上下文SSLContext。
其中HostnameVerifier用来验证服务端证书与域名是否匹配，有多种实现，DefaultHostnameVerifier采纳的是默认的校验规定，代替了之前版本中的BrowserCompatHostnameVerifier与StrictHostnameVerifier。NoopHostnameVerifier代替了AllowAllHostnameVerifier，采纳的是不验证域名的策略。
留神，这里有一些区别，BrowserCompatHostnameVerifier能够匹配多级子域名，”*.foo.com”能够匹配”a.b.foo.com”。StrictHostnameVerifier不能匹配多级子域名，只能到”a.foo.com”。
而4.4之后的HttpClient应用了新的DefaultHostnameVerifier替换了下面的两种策略，只保留了一种严格策略及StrictHostnameVerifier。因为严格策略是IE6与JDK自身的策略，非严格策略是curl与firefox的策略。即默认的HttpClient实现是不反对多级子域名匹配策略的。
SSLContext寄存的是和密钥无关的要害信息，这部分与业务间接相干，十分重要，这个放在前面独自剖析。
4.2 如何取得SSL连贯
如何从连接池中取得一个连贯，这个过程之前的文章中有剖析过，这里不做剖析，参考连贯：http://www.cnblogs.com/kingsz…。
在从连接池中取得一个连贯后，如果这个连贯不处于establish状态，就须要先建设连贯。
DefaultHttpClientConnectionOperator局部的代码为：
public void connect(
final ManagedHttpClientConnection conn,
final HttpHost host,
final InetSocketAddress localAddress,
final int connectTimeout,
final SocketConfig socketConfig,
final HttpContext context) throws IOException {
//之前在HttpClientBuilder中register了http与https不同的连接池实现，这里lookup取得Https的实现，即SSLConnectionSocketFactory
final Lookup<ConnectionSocketFactory> registry = getSocketFactoryRegistry(context);
final ConnectionSocketFactory sf = registry.lookup(host.getSchemeName());
if (sf == null) {
throw new UnsupportedSchemeException(host.getSchemeName() +
" protocol is not supported");
}
//如果是ip模式的地址能够间接应用，否则应用dns解析器解析失去域名对应的ip
final InetAddress[] addresses = host.getAddress() != null ?
new InetAddress[] { host.getAddress() } : this.dnsResolver.resolve(host.getHostName());
final int port = this.schemePortResolver.resolve(host);
//一个域名可能对应多个Ip,依照程序尝试连贯
for (int i = 0; i < addresses.length; i++) {
final InetAddress address = addresses[i];
final boolean last = i == addresses.length - 1;
//这里只是生成一个socket，还并没有连贯
Socket sock = sf.createSocket(context);
//设置一些tcp层的参数
sock.setSoTimeout(socketConfig.getSoTimeout());
sock.setReuseAddress(socketConfig.isSoReuseAddress());
sock.setTcpNoDelay(socketConfig.isTcpNoDelay());
sock.setKeepAlive(socketConfig.isSoKeepAlive());
if (socketConfig.getRcvBufSize() > 0) {
sock.setReceiveBufferSize(socketConfig.getRcvBufSize());
}
if (socketConfig.getSndBufSize() > 0) {
sock.setSendBufferSize(socketConfig.getSndBufSize());
}
final int linger = socketConfig.getSoLinger();
if (linger >= 0) {
sock.setSoLinger(true, linger);
}
conn.bind(sock);
final InetSocketAddress remoteAddress = new InetSocketAddress(address, port);
if (this.log.isDebugEnabled()) {
this.log.debug("Connecting to " + remoteAddress);
}
try {
//通过SSLConnectionSocketFactory建设连贯并绑定到conn上
sock = sf.connectSocket(
connectTimeout, sock, host, remoteAddress, localAddress, context);
conn.bind(sock);
if (this.log.isDebugEnabled()) {
this.log.debug("Connection established " + conn);
}
return;
}
//省略一些代码
}
}
在下面的代码中，咱们看到了是建设SSL连贯之前的筹备工作，这是通用流程，一般HTTP连贯也一样。SSL连贯的非凡流程体现在哪里呢？
SSLConnectionSocketFactory局部源码如下：
@Override
public Socket connectSocket(
final int connectTimeout,
final Socket socket,
final HttpHost host,
final InetSocketAddress remoteAddress,
final InetSocketAddress localAddress,
final HttpContext context) throws IOException {
Args.notNull(host, "HTTP host");
Args.notNull(remoteAddress, "Remote address");
final Socket sock = socket != null ? socket : createSocket(context);
if (localAddress != null) {
sock.bind(localAddress);
}
try {
if (connectTimeout > 0 && sock.getSoTimeout() == 0) {
sock.setSoTimeout(connectTimeout);
}
if (this.log.isDebugEnabled()) {
this.log.debug("Connecting socket to " + remoteAddress + " with timeout " + connectTimeout);
}
//建设连贯
sock.connect(remoteAddress, connectTimeout);
} catch (final IOException ex) {
try {
sock.close();
} catch (final IOException ignore) {
}
throw ex;
}
// 如果以后是SslSocket则进行SSL握手与域名校验
if (sock instanceof SSLSocket) {
final SSLSocket sslsock = (SSLSocket) sock;
this.log.debug("Starting handshake");
sslsock.startHandshake();
verifyHostname(sslsock, host.getHostName());
return sock;
} else {
//如果不是SslSocket则将其包装为SslSocket
return createLayeredSocket(sock, host.getHostName(), remoteAddress.getPort(), context);
}
}
@Override
public Socket createLayeredSocket(
final Socket socket,
final String target,
final int port,
final HttpContext context) throws IOException {
//将一般socket包装为SslSocket,socketfactory是依据HttpClientBuilder中的SSLContext生成的，其中蕴含密钥信息
final SSLSocket sslsock = (SSLSocket) this.socketfactory.createSocket(
socket,
target,
port,
true);
//如果制订了SSL层协定版本与加密算法，则应用指定的，否则应用默认的
if (supportedProtocols != null) {
sslsock.setEnabledProtocols(supportedProtocols);
} else {
// If supported protocols are not explicitly set, remove all SSL protocol versions
final String[] allProtocols = sslsock.getEnabledProtocols();
final List<String> enabledProtocols = new ArrayList<String>(allProtocols.length);
for (final String protocol: allProtocols) {
if (!protocol.startsWith("SSL")) {
enabledProtocols.add(protocol);
}
}
if (!enabledProtocols.isEmpty()) {
sslsock.setEnabledProtocols(enabledProtocols.toArray(new String[enabledProtocols.size()]));
}
}
if (supportedCipherSuites != null) {
sslsock.setEnabledCipherSuites(supportedCipherSuites);
}
if (this.log.isDebugEnabled()) {
this.log.debug("Enabled protocols: " + Arrays.asList(sslsock.getEnabledProtocols()));
this.log.debug("Enabled cipher suites:" + Arrays.asList(sslsock.getEnabledCipherSuites()));
}
prepareSocket(sslsock);
this.log.debug("Starting handshake");
//Ssl连贯握手
sslsock.startHandshake();
//握手胜利后校验返回的证书与域名是否统一
verifyHostname(sslsock, target);
return sslsock;
}
能够看到，对于一个SSL通信而言。首先是建设一般socket连贯，而后进行ssl握手，之后验证证书与域名一致性。之后的操作就是通过SSLSocketImpl进行通信，协定细节在SSLSocketImpl类中体现，但这部分代码jdk并没有开源，感兴趣的能够下载相应的openJdk源码持续剖析。
五、本文总结
- https协定是http的平安版本，做到了传输层数据的平安，但对服务器cpu有额定耗费
- https协定在协商密钥的时候应用非对称加密，密钥协商完结后应用对称加密
- 有些场景下，即便通过了https进行了加解密，业务零碎也会对报文进行二次加密与签名
- HttpClient在build的时候，连接池管理器注册了两个SslSocketFactory，用来匹配http或者https字符串
- https对应的socket建设准则是先建设，后验证域名与证书一致性
- ssl层 加解密由jdk本身实现，不须要httpClient进行额定操作
发表回复