java https

1. 异常突现

在这普通的一天，我写普通的代码，却突然收到不普通的报警

javax.net.ssl.SSLHandshakeException: server certificate change is restrictedduring renegotiation

查看日志访问xx支付的请求全部报错，紧急联系对方，得知对方更换了服务器证书。由于连接池会缓存连接，旧连接不能及时释放，线上一直在持续报警，最终重启服务器，业务才全部恢复正常。

2. 提出疑问

虽然系统恢复了正常,但是有几个问题一直留在我心里:

• 为什么会出现这个异常？
• HttpClient 是如何进行https请求的？
• 除了重启机器，是否还有其他应对方式？

3. 初探Https

本文主要从源码的角度，探寻HttpClient如何进行Https请求，以及Java是如何进行SSL连接,不涉及SSL/TLS具体协议内容。

3.1 Https基础知识

Https的基础知识前辈们已经有了很好的总结,推荐几篇博文,可以学习一下。

• HTTPS深入理解
• HTTPS协议详解 系列

为了更好的理解下文,这里引用两个SSL/TLS握手流程，摘自 HTTPS深入理解

验证服务器握手过程 图1

图片来自网络

(1) 客户端通过Client Hello消息将它支持的SSL版本、加密算法、密钥交换算法、MAC算法等信息发送给SSL服务器。

(2) 服务器确定本次通信采用的版本和加密套件，并通过Server Hello消息通知给客户端。如果服务器允许客户端在以后的通信中重用本次会话，则服务器会为本次会话分配会话ID，并通过Server Hello消息发送给SSL客户端。

(3) 服务器将携带自己公钥信息的数字证书通过Certificate消息发送给客户端。

(4) 服务器发送Server Hello Done消息，通知客户端版本和加密套件协商结束，开始进行密钥交换。

(5) 客户端验证服务器的证书合法后，利用证书中的公钥加密客户端随机生成的premaster secret，并通过Client Key Exchange消息发送给SSL服务器。

(6) 客户端发送Change Cipher Spec消息，通知服务器后续报文将采用协商好的密钥和加密套件进行加密和MAC计算。

(7) 客户端计算已交互的握手消息（除Change Cipher Spec消息外所有已交互的消息）的Hash值，利用协商好的密钥和加密套件处理Hash值（计算并添加MAC值、加密等），并通过Finished消息发送给服务器。服务器利用同样的方法计算已交互的握手消息的Hash值，并与Finished消息的解密结果比较，如果二者相同，且MAC值验证成功，则证明密钥和加密套件协商成功。

(8) 同样地，SSL服务器发送Change Cipher Spec消息，通知客户端后续报文将采用协商好的密钥和加密套件进行加密和MAC计算。

(9) 服务器计算已交互的握手消息的Hash值，利用协商好的密钥和加密套件处理Hash值（计算并添加MAC值、加密等），并通过Finished消息发送给客户端。客户端利用同样的方法计算已交互的握手消息的Hash值，并与Finished消息的解密结果比较，如果二者相同，且MAC值验证成功，则证明密钥和加密套件协商成功。

(10) 客户端接收到服务器发送的Finished消息后，如果解密成功，则可以判断服务器是数字证书的拥有者，即服务器身份验证成功，因为只有拥有私钥的服务器才能从Client Key Exchange消息中解密得到premaster secret，从而间接地实现了客户端对服务器的身份验证。

重用会话的握手过程 图2

协商会话参数、建立会话的过程中，需要使用非对称密钥算法来加密密钥、验证通信对端的身份，计算量较大，占用了大量的系统资源。为了简化SSL握手过程，SSL允许重用已经协商过的会话，具体过程为：

(1) 客户端发送Client Hello消息，消息中的会话ID设置为重用的会话的ID。

(2) 服务器如果允许重用该会话，则通过在Server Hello消息中设置相同的会话ID来应答。这样，客户端和服务器就可以利用原有会话的密钥和加密套件，不必重新协商。

(3) 服务器发送Change Cipher Spec消息，通知客户端后续报文将采用原有会话的密钥和加密套件进行加密和MAC计算。

(4) 服务器计算已交互的握手消息的Hash值，利用原有会话的密钥和加密套件处理Hash值，并通过Finished消息发送给客户端，以便SSL客户端判断密钥和加密套件是否正确。

(5) 客户端发送Change Cipher Spec消息，通知SSL服务器后续报文将采用原有会话的密钥和加密套件进行加密和MAC计算。

(6) 客户端计算已交互的握手消息的Hash值，利用原有会话的密钥和加密套件处理Hash值，并通过Finished消息发送给SSL服务器，以便SSL服务器判断密钥和加密套件是否正确。

3.2 HttpClient 如何处理https/http请求

先看一段小代码,这是一个简单的请求两次考拉主页的代码。通过之后的代码可以看到,在进行第二次请求时,并不会重新建立连接。

public static void main(String[] args) throws IOException {
  CloseableHttpClient httpclient = HttpClients.createDefault();
  HttpGet httpget = new HttpGet("https://www.kaola.com");
  CloseableHttpResponse response1 = httpclient.execute(httpget);

  CloseableHttpResponse response2 = httpclient.execute(httpget);
}

创建CloseableHttpClient实例

首先看一下创建默认的CloseableHttpClient实例做了哪些事情，这里只讲一些核心属性。入口在org.apache.http.impl.client.HttpClientBuilder#build

1. ClientExecChain
   执行链，HttpClient使用了责任链模式，请求通过一系列的执行器最终得到结果，每一个执行器都有自己的职责。下面是默认情况下执行链的顺序:

• RedirectExec：负责处理请求重定向
• RetryExec：负责判断一个由于I/O异常失败的请求是否应该重试
• ProtocolExec：负责处理Http协议，内部使用HttpProcessor来构建必要的Http请求头，并处理Http响应头，更新Session状态到HttpClientContext中
• MainClientExec：执行链的最后一环，负责执行request获取response，使用HttpRequestExecutor发送请求

1. HttpClientConnectionManager
   连接管理器，默认使用的实现时PoolingHttpClientConnectionManager，它创建时注册了支持不同协议的Socket创建工厂,其中https协议对应的是SSLConnectionSocketFactory
   PoolingHttpClientConnectionManager poolingmgr = newPoolingHttpClientConnectionManager( RegistryBuilder.<ConnectionSocketFactory>create() .register("http", PlainConnectionSocketFactory.getSocketFactory()) .register("https", sslSocketFactory) .build());
2. HttpRoutePlanner
   默认实现是DefaultRoutePlanner，它决定一个request的HttpRoute路由信息，包含域名，端口，协议。它的实现必须是线程安全的。

执行Https请求

HttpGet httpget = new HttpGet("https://www.kaola.com");
CloseableHttpResponse response1 = httpclient.execute(httpget);

直接来看执行链的最后一环，这里只说明一些关键代码:

1. 代码入口 org.apache.http.impl.execchain.MainClientExec#execute

public CloseableHttpResponse execute(final HttpRoute route,final HttpRequestWrapper request,
                                     final HttpClientContext context,final HttpExecutionAware execAware) throws IOException, HttpException {
  //...
  //获取连接请求，这里没有真正建立连接
  final ConnectionRequest connRequest = connManager.requestConnection(route, userToken);
  //...
  final RequestConfig config = context.getRequestConfig();
  //获取连接，这里没有真正建立连接
  final HttpClientConnection managedConn;
  try {
    final int timeout = config.getConnectionRequestTimeout();
    managedConn = connRequest.get(timeout > 0 ? timeout : 0, TimeUnit.MILLISECONDS);
  }//... 异常处理

  //...
  final ConnectionHolder connHolder = new ConnectionHolder(this.log, this.connManager, managedConn);
  try {
    //...
    HttpResponse response;
    for (int execCount = 1;; execCount++) {
      //...
      if (!managedConn.isOpen()) {
        try {//2. 建立连接
          establishRoute(proxyAuthState, managedConn, route, request, context);
        } //异常处理
      }
      //执行
      response = requestExecutor.execute(request, managedConn, context);
      //...
    }
    //释放回连接池
  }//...异常处理
}

1. 建立连接org.apache.http.impl.conn.HttpClientConnectionOperator#connect
establishRoute方法里，最终会调用connect方法

public void connect(final ManagedHttpClientConnection conn,final HttpHost host,
                    final InetSocketAddress localAddress,final int connectTimeout,
                    final SocketConfig socketConfig,final HttpContext context) throws IOException {
  //根据协议获取对应的Socket工厂
  final Lookup<ConnectionSocketFactory> registry = getSocketFactoryRegistry(context);
  //因为是https协议，这里获取到SSLConnectionSocketFactory
  final ConnectionSocketFactory sf = registry.lookup(host.getSchemeName());
  //这里会从dns查到多个IP地址，如果连接失败，会尝试连接下一个IP
  final InetAddress[] addresses = host.getAddress() != null ?
    new InetAddress[] { host.getAddress() } : this.dnsResolver.resolve(host.getHostName());
  final int port = this.schemePortResolver.resolve(host);
  for (int i = 0; i < addresses.length; i++) {
    final InetAddress address = addresses[i];
    final boolean last = i == addresses.length - 1;

    Socket sock = sf.createSocket(context);//注意，这里创建的一个普通的socket连接
    //...
    conn.bind(sock);
    //...
    try {//3. 建立TLS连接
      sock = sf.connectSocket(connectTimeout, sock, host, remoteAddress, localAddress, context);
      conn.bind(sock);
      return;
    }//处理异常
 }

1. 建立TLS连接 org.apache.http.conn.ssl.SSLConnectionSocketFactory#connectSocket
   这里需要注意，Https协议是基于SSL/TLS协议，SSL/TLS是基于TCP协议，所以我们需要先建立TCP连接，再建立SSL/TLS连接，最后在SSL/TLS上传输Http报文。

public Socket connectSocket(final int connectTimeout,final Socket socket,
    final HttpHost host,final InetSocketAddress remoteAddress,
    final InetSocketAddress localAddress,final HttpContext context) throws IOException {
  //...
  try {
      sock.connect(remoteAddress, connectTimeout);//建立TCP连接
  } //异常处理
   //...
   //建立TLS连接
   return createLayeredSocket(sock, host.getHostName(), remoteAddress.getPort(), context);
}

org.apache.http.conn.ssl.SSLConnectionSocketFactory#createLayeredSocket

public Socket createLayeredSocket(final Socket socket,final String target,
        final int port,final HttpContext context) throws IOException {
    //基于socket创建SSLScoket
    final SSLSocket sslsock = (SSLSocket) this.socketfactory.createSocket(socket,target,port,true);
    //...
    prepareSocket(sslsock);//空实现，预留的hook
    sslsock.startHandshake();//开始握手
    verifyHostname(sslsock, target);
    return sslsock;
}

到此HttpClient的请求部分就结束了，连接成功后会进行正常的数据交互(https有些特殊处理)，下面看一下Java如何建立SSL/TLS连接

3.3 Java建立SSL/TLS连接

从这里开始没有源码，部分变量名是根据自己的理解填充的，不过JDK的自解释性还是很好的，大部分都可以理解

执行初始化握手

sun.security.ssl.SSLSocketImpl#performInitialHandshake

private void performInitialHandshake() throws IOException {
  synchronized(this.handshakeLock) {
    if(this.getConnectionState() == 1) {//连接状态初始化，如果复用连接不会走到这
      this.kickstartHandshake();//1.开始握手，发送Client Hello消息
      //...2. 读取服务端返回数据
      this.readRecord(this.inrec, false);
      this.inrec = null;
    }

  }
}

1. 发送Client Hello消息sun.security.ssl.Handshaker#kickstart

这里对应图1中的(1)

void kickstart() throws IOException {
    if(this.state < 0) {
        HandshakeMessage messge = this.getKickstartMessage();//构造消息体
        //发送消息
        messge.write(this.output);
        this.output.flush();
        this.state = messge.messageType();//握手消息 messageType=22
    }
}

构造Client Hello消息体sun.security.ssl.ClientHandshaker#getKickstartMessage

HandshakeMessage getKickstartMessage() throws SSLException {
    SessionId sessionId = SSLSessionImpl.nullSession.getSessionId();
    CipherSuiteList cipherSuiteList = this.getActiveCipherSuites();
    this.maxProtocolVersion = this.protocolVersion;
    //取session，这里是造成异常的原因，之后分析
    this.session = ((SSLSessionContextImpl)this.sslContext.engineGetClientSessionContext()).get(this.getHostSE(),this.getPortSE());
    //...
    if(this.session != null) {
       //从sessino中还原信息
    }
    if(this.session == null && !this.enableNewSession) {
        throw new SSLHandshakeException("No existing session to resume");
    } else {
       //获取可支持的加密套件
        if(!isNegotiable) {
            throw new SSLHandshakeException("No negotiable cipher suite");
        } else {
              //这里会把sessionId添加到ClientHello消息
            ClientHello clientHello = new ClientHello(this.sslContext.getSecureRandom(), this.maxProtocolVersion, sessionId, cipherSuiteList);
              //...
            return clientHello;
        }
    }
}

1. 接收服务端数据sun.security.ssl.SSLSocketImpl#readRecord

一直循环的读取服务端数据，直到握手完成

private void readRecord(InputRecord inputRecord, boolean var2) throws IOException {
  synchronized(this.readLock) {
      while(true) {
          int var3;
          if((var3 = this.getConnectionState()) != 6 && var3 != 4 && var3 != 7) {
              try {
                  inputRecord.setAppDataValid(false);
                  //读取服务器返回
                  inputRecord.read(this.sockInput, this.sockOutput);
              } //异常处理
              //解码
              synchronized(this) {
                  switch(inputRecord.contentType()) {//根据不同的消息类型进行处理
                  case 20://change_cipher_spec 服务端通知更换密钥 图1 (8)
                      //...
                      this.changeReadCiphers();
                      this.expectingFinished = true;
                      continue;
                  case 21://alert
                      this.recvAlert(inputRecord);
                      continue;
                  case 22://handshake 握手相关消息
                      this.initHandshaker();//初始化ClientHandshaker
                      //...
                      //处理数据
                      this.handshaker.process_record(inputRecord, this.expectingFinished);
                      this.expectingFinished = false;
                      //... 完成握手,保存信息,退出
                      continue;
                  case 23://application_data
                      //...
                      break;
                  default:
                     //...
              }
              return;
          }
          inputRecord.close();
          return;
      }
  }
}

查看process_record方法的调用链，最终会找到握手消息处理的方法sun.security.ssl.ClientHandshaker#processMessage，通过不同的消息类型进行不同的处理，可以对照图1的理解.

void processMessage(byte handshakeType, int length) throws IOException {
    if(this.state >= handshakeType && handshakeType != 0) {
        //... 异常
    } else {
        label105:
        switch(handshakeType) {
        case 0://hello_request
            this.serverHelloRequest(new HelloRequest(this.input));
            break;
        //...
        case 2://sever_hello 图1 (2)
            this.serverHello(new ServerHello(this.input, length));
            break;
        case 11:///certificate 图1 (3)
            this.serverCertificate(new CertificateMsg(this.input));
            this.serverKey = this.session.getPeerCertificates()[0].getPublicKey();
            break;
        case 12://server_key_exchange 该消息并不是必须的，取决于协商出的key交换算法
            //...
        case 13: //certificate_request 客户端双向验证时需要
            //...
        case 14://server_hello_done 图1 (4)
            this.serverHelloDone(new ServerHelloDone(this.input));
            break;
        case 20://finished 图1 (9)
            this.serverFinished(new Finished(this.protocolVersion, this.input, this.cipherSuite));
        }
        if(this.state < handshakeType) {//握手状态
            this.state = handshakeType;
        }
    }
}

在sun.security.ssl.ClientHandshaker#serverHelloDone方法中，客户端会根据服务端返回加密套件决定加密方式，构造不同的Client Key Exchange消息,例如RSAClientKeyExchange，DHClientKeyExchange,ECDHClientKeyExchange 对应图1 (5).

发送ClientKeyExchange后，紧接着sendChangeCipherAndFinish方法会发送Change Cipher Spec消息和Finished消息，对应图1 (6) (7).

之后接收服务端的Change Cipher Spec 消息 图1 (8)，完成密钥切换后，等待Finished消息 图1 (9)，如果此时不是恢复会话过程，会见session存入缓存中

至此成功建立连接，由于篇幅有限，每一步具体的收发消息就不细述,跟着上述分析可以清楚的找到所有入口。

3.4 复用会话的握手过程

复用会话的流程包含在是在上述流程中,只是部分节点会判断是否存在session，是否是恢复会话过程 进行不同的动作

1. 携带Session信息的Client Hello 图2 (1)

在握手时会查看缓存时是否已经存在session (key=ip:port) ，如果存在session,在Client Hello消息中会带上session信息sun.security.ssl.ClientHandshaker#getKickstartMessage

this.sslContext.engineGetClientSessionContext()).get(this.getHostSE(),this.getPortSE());

1. 携带Sessin信息的Server Hello 图2 (2)

在sun.security.ssl.ClientHandshaker#serverHello方法中会判断客户端sessionId与服务端传来的是否一致

if(this.session.getSessionId().equals(severHello.sessionId)) {
  //从session中恢复信息
}

1. 接收Change Cipher Spec消息 图2 (3)

在sun.security.ssl.SSLSocketImpl#changeReadCiphers方法中处理

1. 接收Finished消息 图2 (4)

在收到Finished消息后,于初次建立连接不同，如果判断恢复会话，会发出Change Cipher Spec消息和Finished消息，对应图2 (5)(6)

if(this.resumingSession) {
    this.input.digestNow();
    this.sendChangeCipherAndFinish(true);
}

3.6 数据发送

SSL/TLS建立连接之后，Http报文将如何发送？

对于上层来说并不需要关注SSL/TLS层，数据会由SSLSocketImpl进行加密，解密。发送Http报文的入口在

org.apache.http.protocol.HttpRequestExecutor#execute，底层使用AppOutputStream输出流。最终由sun.security.ssl.SSLSocketImpl#writeRecordInternal输出数据

private void writeRecordInternal(OutputRecord outputRecord, boolean var2) throws IOException {
    outputRecord.addMAC(this.writeMAC);
    outputRecord.encrypt(this.writeCipher);//数据加密
    //...
    outputRecord.write(this.sockOutput, var2, this.heldRecordBuffer);//输出
    //...
}

4. 解决疑问

发生了什么?为什么会出现异常？

服务端更换证书后，客户端建立的SSL/TLS连接并没有失效，在握手时使用缓存中的sessionId进行简化的握手流程，由此触发了异常。

HttpClient如何进行Https请求？

HttpClient根据不同的协议使用不同的Socket工厂创建连接，对于https会使用SSLConnectionSocketFactory.具体的SSL/TLS连接建立过程交由SSLSocketImpl处理。

建立连接后会HttpClient并不需要关注底层的数据加密，SSLSocketImpl会负责数据的读写。

如何处理？

重启机器

由于连接池的存在，等待连接报错重新建立新的连接不是一个好的选择，这可能会造成系统持续异常。如果没有其他措施，重启大法欢迎你。

禁用session

在建立连接之后使缓存失效可以避免使用简化的握手流程，不过性能影响较大，不提倡

SSLSocket.getSession().invalidate();

失效连接

既然是因为连接池的存在要重启机器，那我们可以把连接池清空。在连接池管理器PoolingHttpClientConnectionManager中有清理空闲连接的方法。

void closeIdleConnections(long idletime, TimeUnit tunit);

我们可以将idletime设置很小，就可以关闭大部分连接了。不过这样做法有些粗暴，可能会造成误伤。

连接池是可以自定义的，按需要定制自己想要的功能，如远程清空连接池，更精细一些，根据ip+port清理指定的连接。

https://zhuanlan.zhihu.com/p/44786952