如何主导设计一个亿级高并发系统架构 - 通信协议加密(二)

“ 架设一个亿级高并发系统，是多数程序员、架构师的工作目标。 许多的技术从业人员甚至有时会降薪去寻找这样的机会。但并不是所有人都有机会主导，甚至参与这样一个系统。这个系列我们通过虚构一个这样的系统，一步步来完善我们的架构理念。”

01

—

通信协议加密

从0到1主导一个亿级平台，基本上也要负责以下6块内容，本章内容我们关注在通信协议。

通信协议：一个私有的通信协议可以解决99%以上的非法访问，我们设计一个平台时首先要保障的就是我们后台接收的所有请求都是合法的有效请求，这样我们接口容量设计才能满足系统的用户增长和性能指标。

我们以APP为例，在设计通信时我们需要保证后台服务知道在和哪个终端通信。

GUID:

这里我们需要为APP打到一个id烙印，一般在行业内我们称呼它为GUID (Global User ID), 这个ID就是每一个APP客户端的标识， 这个标识要求APP端开发人员在用户删除应用时这个ID依然存在。

支付宝在Android端的解决方案是分别在APP文件内，临时文件目录和手机系统文件目录分别保存这个ID。可以保障在APP被删除，临时文件被清理的时候依保留全局ID。

当然有更严格的APP， 在手机重刷ROM的时候重新生成的GUID依然保持一致（这个算法有专利），这个ID的存在可以有效的防控黑产。

通信协议整个过程设计：

1. 获取密钥，这一步的关键是要和APP端约定一个获取密钥的方法，这一块推RSA加密算法，通过公钥、私钥的方法获取接下来的加密密钥。当然这一块需要将逻辑写死在APP端，所以最好用C++写好封装起来再加壳防止被反编译。

我们用JAVA实现一些加解密过程：

package com.leetcode.dynamic.programming.encryption;

import java.io.IOException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class Encryption {

    //生成秘钥对
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        return keyPair;
    }

    //获取公钥(Base64编码)
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return byte2Base64(bytes);
    }

    //获取私钥(Base64编码)
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return byte2Base64(bytes);
    }

    //将Base64编码后的公钥转换成PublicKey对象
    public static PublicKey string2PublicKey(String pubStr) throws Exception{
        byte[] keyBytes = base642Byte(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    //将Base64编码后的私钥转换成PrivateKey对象
    public static PrivateKey string2PrivateKey(String priStr) throws Exception{
        byte[] keyBytes = base642Byte(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    //公钥加密
    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }

    //私钥解密
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }

    //字节数组转Base64编码
    public static String byte2Base64(byte[] bytes){
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(bytes);
    }

    //Base64编码转字节数组
    public static byte[] base642Byte(String base64Key) throws IOException{
        BASE64Decoder decoder = new BASE64Decoder();
        return decoder.decodeBuffer(base64Key);
    }

    public static void main(String[] args) {
        try {
            //===============生成公钥和私钥==================
            //生成RSA公钥和私钥，并Base64编码
            KeyPair keyPair = Encryption.getKeyPair();
            String publicKeyStr = Encryption.getPublicKey(keyPair);
            String privateKeyStr = Encryption.getPrivateKey(keyPair);
            System.out.println("RSA公钥Base64编码:" + publicKeyStr);
            System.out.println("RSA私钥Base64编码:" + privateKeyStr);

            //=================用公钥加密数据=================
            String key = "abc";
            //将Base64编码后的公钥转换成PublicKey对象
            PublicKey publicKey = Encryption.string2PublicKey(publicKeyStr);
            //用公钥加密
            byte[] publicEncrypt = Encryption.publicEncrypt(key.getBytes(), publicKey);
            //加密后的内容Base64编码
            String byte2Base64 = Encryption.byte2Base64(publicEncrypt);
            System.out.println("公钥加密并Base64编码的结果：" + byte2Base64);



            //===================用私钥解密数据================
            //将Base64编码后的私钥转换成PrivateKey对象
            PrivateKey privateKey = Encryption.string2PrivateKey(privateKeyStr);
            //加密后的内容Base64解码
            byte[] base642Byte = Encryption.base642Byte(byte2Base64);
            //用私钥解密
            byte[] privateDecrypt = Encryption.privateDecrypt(base642Byte, privateKey);
            //解密后的明文
            System.out.println("解密后的明文: " + new String(privateDecrypt));
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

}

根据代码逻辑生成公钥、私钥，将私钥写死在APP端的代码中，客户端拿到加密后的数据后通过自己的私钥解密数据，从而拿到自己的密钥“abc”。

2. GUID生成：

生成GUID的逻辑可以用AES加固定盐值的方式加密，这样客户端通过GUID与服务端通信的时候就可以验证GUID是否合法。

另外这里传输GUID可以用同样的逻辑将GUID传输给客户端。

3. 生成签名： 这里的签名要求客户端每次发起请求时，生成一个新的签名，这个逻辑可以自己设计。也可以简单地用MD5进一行一次加密如：MD5(密钥+时间戳+GUID)， 服务端可以用同样的方法进行验证是否有效，再验证签名是否已经用过。（这种情况下，抓包刷接口就有一定的技术门槛了）
4. 至此准备工作就基本结束，下面我们来体验一下一次完整加密通信的交互过程：

当然我们服务端和客户端都有同样的密钥了，怎么加解密数据可能根据自己的业务安全级别选择不同的加密方式。

当然有的同学可能想说，如果每个业务里面都用这么复杂的加解密方法，那调试代码和测试的时候不是异常复杂。其实整个加解密和校验过程都可以放到网关项目里面，各业务团队完全可以只关心自己的业务的部分。

有兴趣的同学可以去看一下之前写的文章 “Spring Cloud Alibaba 网关应用-Springcloud Gateway(六）”

好了，今天的内容就到这里。最后我们思考一个问题：

如果一个已经存在的系统，其接口通信采用明文的通信方式，我们怎么做才能无缝地切换到加密通信的方式？

欢迎留言。