public static OkHttpClient createEncryptedOkHttpClient() {
// 创建一个OkHttpClient.Builder

    OkHttpClient.Builder builder = new OkHttpClient.Builder();

// 添加自定义拦截器，用于加密请求内容

    builder.addInterceptor(new EncryptionInterceptor());

// 创建OkHttpClient实例
return builder.build();

}

private RequestBody encryptRequestBody(RequestBody originalRequestBody) throws IOException {
// 从原始RequestBody中读取字节数据
// Read the byte data from the original RequestBody using Okio
Buffer buffer = new Buffer();

    originalRequestBody.writeTo(buffer);
byte[] bytes = buffer.readByteArray();

// 使用对称加密算法（AES）加密字节数据
byte[] encryptedBytes = encryptWithAES(bytes, SECRET_KEY);

// 创建新的RequestBody
return RequestBody.create(originalRequestBody.contentType(), encryptedBytes);

}

private byte[] encryptWithAES(byte[] input, String key) {
try {
SecretKey secretKey = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), AES_ALGORITHM);
Cipher cipher = Cipher.getInstance(AES_ALGORITHM);

        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
return cipher.doFinal(input);

    } catch (Exception e) {

        e.printStackTrace();
return new byte[0];

    }

}

public static String decrypt(String encryptedText) {
try {
byte[] encryptedData = Base64.decode(encryptedText,Base64.DEFAULT);

SecretKey secretKey = new SecretKeySpec(SECRET_KEY.getBytes(StandardCharsets.UTF_8), AES_ALGORITHM);
Cipher cipher = Cipher.getInstance(AES_ALGORITHM);

        cipher.init(Cipher.DECRYPT_MODE, secretKey);

byte[] decryptedBytes = cipher.doFinal(encryptedData);

return new String(decryptedBytes, StandardCharsets.UTF_8);

    } catch (Exception e) {

        e.printStackTrace();
return null;

    }

}

// 添加自定义拦截器，用服务器非对称加密的公钥加密对称加密的密钥，然后用对称加密密钥加密请求内容

builder.addInterceptor(new MixtureEncryptionInterceptor());

private RequestBody encryptRequestBody(RequestBody originalRequestBody) throws IOException {
// 生成对称加密的密钥
byte[] secretKeyBytes = generateSecretKey();

    SecretKeySpec secretKeySpec = new SecretKeySpec(secretKeyBytes, "AES");
// 使用服务器的公钥加密对称加密的密钥
byte[] encryptedSecretKey = encryptWithPublicKey(secretKeyBytes, SERVER_PUBLIC_KEY);
// 从原始 RequestBody 中读取字节数据

    Buffer buffer = new Buffer();

    originalRequestBody.writeTo(buffer);
byte[] bytes = buffer.readByteArray();

// 使用对称加密算法（AES）加密请求体
byte[] encryptedRequestBodyBytes = encryptWithAES(bytes, secretKeySpec);

// 创建新的 RequestBody，将加密后的密钥和请求体一并传输
return RequestBody.create(null, concatenateArrays(encryptedSecretKey, encryptedRequestBodyBytes));

}

/**

 * try block 里使用的是加密算法和随机数生成器，生成的较为复杂的密钥

 * catch block 里使用的是示范性的非安全密钥

 * @return

 */
private byte[] generateSecretKey() {
// 生成对称加密的密钥
try {
// 创建KeyGenerator对象，指定使用AES算法
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");

// 初始化KeyGenerator对象，设置密钥长度为128位

        keyGenerator.init(128, new SecureRandom());

// 生成密钥
SecretKey secretKey = keyGenerator.generateKey();

// 获取密钥的字节数组表示形式
byte[] keyBytes = secretKey.getEncoded();

// 打印密钥的字节数组表示形式
for (byte b : keyBytes) {

            Log.d(TAG,b + " ");

        }
return keyBytes;

    } catch (NoSuchAlgorithmException e) {

        e.printStackTrace();
// 这里简单地示范了生成密钥的过程，实际上可以使用更复杂的方法来生成密钥
return "YourSecretKey".getBytes(StandardCharsets.UTF_8);

    }


}

private byte[] encryptWithPublicKey(byte[] input, String publicKeyString) {
try {
// 封装 PublicKey
byte[] keyBytes = Base64.decode(publicKeyString, Base64.DEFAULT);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

return cipher.doFinal(input);

    } catch (NoSuchAlgorithmException | InvalidKeySpecException | NoSuchPaddingException |

             InvalidKeyException | BadPaddingException | IllegalBlockSizeException e) {

        e.printStackTrace();
return new byte[0];

    }

}

将服务端提供的公钥字符串转化成字节数组，然后通过 RSA 非对称算法加密 input，也就是我们的对称密钥。

注意：Cipher.getInstance("RSA/ECB/PKCS1Padding") 表示获取一个Cipher对象，该对象使用RSA算法、ECB模式和PKCS1填充方式。

3. 使用对称加密算法（AES）加密请求体，请求体仍然要用对称加密密钥加密，只是对称加密密钥用公钥保护起来

private byte[] encryptWithAES(byte[] input, SecretKeySpec secretKeySpec) {
try {
Cipher cipher = Cipher.getInstance("AES");

        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
return cipher.doFinal(input);

    } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException |

             BadPaddingException | IllegalBlockSizeException e) {

        e.printStackTrace();
return new byte[0];

    }


}

非对称加密加密内容，策略一已经实现了。

4. 创建新的 RequestBody，将加密后的密钥和请求体一并传输，这样就算 hacker 拦截了请求解析出请求体的数据，也无法直接获取到原始对称密钥。 加密完成后，通过 concatenateArrays 方法将加密后的密钥和请求体，实现如下：

private byte[] concatenateArrays(byte[] a, byte[] b) {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try {

        outputStream.write(a);

        outputStream.write(b);

    } catch (IOException e) {

        e.printStackTrace();

    } finally {
try {

            outputStream.close();

        } catch (IOException e) {

            e.printStackTrace();

        }

    }
return outputStream.toByteArray();

}

非对称加密解决了密钥网络传输的问题，但是 hacker 还是可以伪装成目标服务端，骗取客户端的密钥。在伪装成客户端，用服务端的公钥加密自己篡改的内容，目标服务端对此无法辨别真伪。这就需要证书校验。

策略三：证书校验（单向认证）

okhttp3 提供了CertificatePinner这个类用于证书校验，CertificatePinner 可以验证服务器返回的证书是否是预期的证书。在创建createEncryptedOkHttpClient()方法中，添加证书代码如下：

okhttp 会利用其内置的证书固定机制来校验服务器返回证书的有效性。如果证书匹配，请求会继续进行；如果不匹配，OkHttp会抛出一个异常，通常是一个SSLPeerUnverifiedException，表明证书验证失败。验证过程在CertificatePinner 类的check()方法中，如下：

/**

 * Confirms that at least one of the certificates pinned for {@code hostname} is in {@code

 * peerCertificates}. Does nothing if there are no certificates pinned for {@code hostname}.

 * OkHttp calls this after a successful TLS handshake, but before the connection is used.

 *

 * @throws SSLPeerUnverifiedException if {@code peerCertificates} don't match the certificates

 * pinned for {@code hostname}.

 */
public void check(String hostname, List peerCertificates)
throws SSLPeerUnverifiedException {

  List pins = findMatchingPins(hostname);
if (pins.isEmpty()) return;

if (certificateChainCleaner != null) {

    peerCertificates = certificateChainCleaner.clean(peerCertificates, hostname);

  }

for (int c = 0, certsSize = peerCertificates.size(); c < certsSize; c++) {
X509Certificate x509Certificate = (X509Certificate) peerCertificates.get(c);

// Lazily compute the hashes for each certificate.
ByteString sha1 = null;
ByteString sha256 = null;

for (int p = 0, pinsSize = pins.size(); p < pinsSize; p++) {
Pin pin = pins.get(p);
if (pin.hashAlgorithm.equals("sha256/")) {
if (sha256 == null) sha256 = sha256(x509Certificate);
if (pin.hash.equals(sha256)) return; // Success!

      } else if (pin.hashAlgorithm.equals("sha1/")) {
if (sha1 == null) sha1 = sha1(x509Certificate);
if (pin.hash.equals(sha1)) return; // Success!

      } else {
throw new AssertionError();

      }

    }

  }

// If we couldn't find a matching pin, format a nice exception.
StringBuilder message = new StringBuilder()

      .append("Certificate pinning failure!")

      .append("\n  Peer certificate chain:");
for (int c = 0, certsSize = peerCertificates.size(); c < certsSize; c++) {
X509Certificate x509Certificate = (X509Certificate) peerCertificates.get(c);

    message.append("\n    ").append(pin(x509Certificate))

        .append(": ").append(x509Certificate.getSubjectDN().getName());

  }

  message.append("\n  Pinned certificates for ").append(hostname).append(":");
for (int p = 0, pinsSize = pins.size(); p < pinsSize; p++) {
Pin pin = pins.get(p);

    message.append("\n    ").append(pin);

  }
throw new SSLPeerUnverifiedException(message.toString());

}

从校验方法中得知，

可以看到，使用相当方便。但是它有一个问题：请求之前需要预先知道服务端证书的 hash 值。就是说如果证书到期需要更换，老版本的应用就无法获取到更新的证书 hash 值了，老用户要统一升级。这～～～

策略四：创建SSLContext认证（客户端、服务端双向认证）

除了固定证书校验，还有一种基于 SSLContext 的校验方式。在建立HTTPS连接时，在客户端它依赖 SSLContext 和 TrustManager 来验证服务端证书。这里我们通过一createTwoWayAuthClient()方法实现如下：

private static OkHttpClient createTwoWayAuthClient() throws IOException, CertificateException, KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException, KeyManagementException {
// 服务器证书
InputStream serverCertStream = TwoWayAuthHttpClient.class.getResourceAsStream("/server_certificate.crt");
X509Certificate serverCertificate = readCertificate(serverCertStream);
if (serverCertStream != null) {

        serverCertStream.close();

    }

// 客户端证书和私钥
InputStream clientCertStream = TwoWayAuthHttpClient.class.getResourceAsStream("/client_centificate.p12");
KeyStore clientKeyStore = KeyStore.getInstance("PKCS12");

    clientKeyStore.load(clientCertStream, "client_password".toCharArray());
if (clientCertStream != null) {

        clientCertStream.close();

    }

// 创建 KeyManagerFactory 和 TrustManagerFactory
KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());

    keyManagerFactory.init(clientKeyStore, "client_password".toCharArray());

// 创建信任管理器，信任服务器证书
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());

    trustStore.load(null, null);

    trustStore.setCertificateEntry("server", serverCertificate);

    trustManagerFactory.init(trustStore);

// 初始化 SSL 上下文
SSLContext sslContext = SSLContext.getInstance("TLS");

    sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), new SecureRandom());

// 创建 OkHttpClient
return new OkHttpClient.Builder()

            .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustManagerFactory.getTrustManagers()[0])

            .build();

}

private static X509Certificate readCertificate(InputStream inputStream) throws CertificateException {
CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
return (X509Certificate) certificateFactory.generateCertificate(inputStream);

}

注意：/server_certificate.crt可以动态加载服务器自签名证书的办法避免更新旧版本应用

2. 加载客户端证书和私钥：
   • 同样使用getResourceAsStream从类路径中加载客户端证书和私钥文件（.p12格式，通常是PKCS#12格式的密钥库）。
   • 创建一个KeyStore实例，并使用PKCS12算法加载客户端证书和私钥。密码为"client_password"。
   • 关闭输入流。
3. 创建KeyManagerFactory和TrustManagerFactory：
   • KeyManagerFactory用于管理客户端的私钥和证书，以便在建立SSL/TLS连接时使用。
   • TrustManagerFactory用于管理信任的证书，以便在建立SSL/TLS连接时验证服务器的证书。
   • 使用默认算法初始化这两个工厂，并分别加载客户端的密钥库和信任的服务器证书。
4. 初始化SSLContext：
   • 创建一个SSLContext实例，指定使用TLS协议。
   • 使用之前创建的KeyManagerFactory和TrustManagerFactory初始化SSLContext。这会将客户端的私钥和证书，以及信任的服务器证书整合到SSL/TLS握手过程中。
5. 创建OkHttpClient：
   • 使用OkHttpClient.Builder创建一个新的OkHttpClient实例。
   • 配置SSL套接字工厂和信任管理器，以确保在建立连接时使用两向认证。
   • 构建并返回配置好的OkHttpClient实例。

这样客户端发起请求时，会将客户端证书发送给服务端，同时会校验服务端握手时返回的证书。校验逻辑如下：

这样整个双向校验工作就完成了。

封装

腾讯云有个同学封装了库，主要给服务端使用的，看的挺有味道，可以参考 cloud.tencent.com/developer/a…

总结

okhttp 作为一个支持 HTTPS 协议的网络库，同时支持对称加密、非对称加密、客户端证书校验、客户端、服务端双向证书校验等安全加密方式，足见其强大的功能。

此外，为了兼顾性能：它使用证书校验保证通信双方的合法性，使用对称加密加密传输内容保证性能，使用非对称加密加密对称密钥防止hacker 拦截，整体提高了网络通信的安全性。

FAQ

文章被郭霖老师转发后，同学们也提出了一些疑问：
Q: HTTPS为啥不能保证全链路安全？

1. 端点安全性: 如果你的手机、电脑、服务器中毒了，不管输入啥私密信息，都会被病毒软件截胡，https 管不了这事儿。需要杀毒软件大显身手了，给腾讯手机管家做个广告～
2. 中间人攻击： hacker 通过非法方式获得 CA 证书，满足了 https 的安全策略，可以与客户端通信。okhttp 可以通过证书锁定（Certificate Pinning）的方式，只跟特定的服务器通讯，自签名证书不通过，就算 hacker 黑了 CA 机构你也不怕
3. 协议漏洞：okhttp 团队也会定期更新修复漏洞，所以版本该升级升级

Q: SSLContext如何动态更新证书

其实这个问题的关键还是不理解 your_certificate.crt 下载过程中被攻击了咋办。首先，第一版应用的证书秘密存储。其次，后期更新的过程中，下载链路是安全的，自动替换最新的证书并通过安全校验就 OL

Q：PKCS1 有安全问题，建议使用 OAEP

import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RSAUtil {
public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);

    }

public static byte[] decrypt(byte[] encryptedData, PrivateKey privateKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");

        cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(encryptedData);

    }

public static PublicKey getPublicKey(byte[] publicKeyBytes) throws Exception {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePublic(keySpec);

    }

public static PrivateKey getPrivateKey(byte[] privateKeyBytes) throws Exception {
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePrivate(keySpec);

    }

}

Q：证书固定问题

Certificate Pinning 涉及到涉及到三层证书：根证书（Root Certificate）、中间证书（Intermediate Certificate）和服务器证书（Server Certificate）。每个证书都有自己的公钥，因此在证书固定中需要验证这三个证书的公钥。 具体做法是，将服务器证书和根证书的 hash 值添加到证书固定中，这样，在建立连接时，除了验证服务器证书的公钥外，还会验证中间证书和根证书的公钥，确保整个证书链的完整性和真实。

这里以 example.com为例：

import okhttp3.CertificatePinner;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public class CertificatePinningExample {

public static void main(String[] args) throws Exception {
OkHttpClient client = new OkHttpClient.Builder()

                .certificatePinner(new CertificatePinner.Builder()

                        .add("example.com", "sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=") // 服务器证书的哈希值

                        .add("example.com", "sha256/BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB=") // 根证书的哈希值

                        .build())

                .build();

Request request = new Request.Builder()

                .url("https://example.com")

                .build();

try (Response response = client.newCall(request).execute()) {

            System.out.println(response.body().string());

        }

    }

}

AI 是个好东西～

参考文章