客户端和服务端基于RSA非对称加密问题——关键接口防刷

业务需求：为了防止业务中关键接口被刷（对于网赚类业务，提现和收益类接口属于关键接口），客户端和服务端采用非对称加密进行安全校验。

思路：1、为不影响产品使用体验，仅对关键接口（关键接口一般非频繁操作）进行加密

           2、将时间戳作为加密项之一，防止同一个签名可以使用多次

           3、服务端对定义的关键接口请求做校验，限制一个签名只能使用一次，并做签名合法性校验

流程：1、服务端生成秘钥对，将公钥给客户端，本地保存私钥

　　    2、客户端使用公钥对数据进行加密（**+timestamp*），前端请求的话通过事件向客户端拿签名

           3、服务端对前端/客户端请求中的签名进行校验

客户端代码：Android端kotlin

object RSA {
    val charset: Charset = Charset.forName("UTF-8")
    const val KEY_SIZE = 1024
    private const val KEY_ALGORITHM = "RSA/ECB/PKCS1Padding"
    const val SIGNATURE_ALGORITHM = "SHA256withRSA"
    private const val PUBLIC_KEY = "******************************************"
    private const val PRIVATE_KEY = "123123"

    @Throws(java.lang.Exception::class)
    fun generateKeyPair(): KeyPair? {
        val generator = KeyPairGenerator.getInstance("RSA")
        generator.initialize(2048, SecureRandom())
        return generator.generateKeyPair()
    }

    @Throws(java.lang.Exception::class)
    fun string2PrivateKey(priStr: String): PrivateKey? {
        val keyBytes: ByteArray = Base64.decode(priStr, Base64.NO_WRAP)
        val pkcs8EncodedKeySpec = PKCS8EncodedKeySpec(keyBytes)
        val kf = KeyFactory.getInstance("RSA")
        return kf.generatePrivate(pkcs8EncodedKeySpec)
    }

    @Throws(java.lang.Exception::class)
    fun string2PublicKey(pubStr: String): PublicKey? {
        val keyBytes: ByteArray = Base64.decode(pubStr, Base64.NO_WRAP)
        val keySpec = X509EncodedKeySpec(keyBytes)
        val keyFactory = KeyFactory.getInstance("RSA")
        return keyFactory.generatePublic(keySpec)
    }

    /**
     * 加密
     */
    @Throws(java.lang.Exception::class)
    fun encrypt(data: String): String? {
        return encrypt(data, string2PublicKey(PUBLIC_KEY))
    }

    @Throws(java.lang.Exception::class)
    fun encrypt(plainText: String, publicKey: PublicKey?): String? {
        val encryptCipher = Cipher.getInstance(KEY_ALGORITHM)
        encryptCipher.init(Cipher.ENCRYPT_MODE, publicKey)
        val cipherText = encryptCipher.doFinal(plainText.toByteArray(StandardCharsets.UTF_8))
        return Base64.encodeToString(cipherText, Base64.NO_WRAP)
    }

    @Throws(java.lang.Exception::class)
    fun decrypt(cipherText: String?): String? {
        return decrypt(cipherText, string2PrivateKey(PRIVATE_KEY))
    }

    @Throws(java.lang.Exception::class)
    fun decrypt(cipherText: String?, privateKey: PrivateKey?): String? {
        val bytes = Base64.decode(cipherText?.toByteArray(), Base64.NO_WRAP)
        val decriptCipher = Cipher.getInstance(KEY_ALGORITHM)
        decriptCipher.init(Cipher.DECRYPT_MODE, privateKey)
        Log.debug(TAG, decriptCipher.provider.name)
        return String(decriptCipher.doFinal(bytes), StandardCharsets.UTF_8)
    }

    @Throws(java.lang.Exception::class)
    fun sign(plainText: String, privateKey: PrivateKey?): String? {
        val privateSignature = Signature.getInstance(SIGNATURE_ALGORITHM)
        privateSignature.initSign(privateKey)
        privateSignature.update(plainText.toByteArray(StandardCharsets.UTF_8))
        val signature = privateSignature.sign()
        return Base64.encodeToString(signature, Base64.NO_WRAP)
    }

    @Throws(java.lang.Exception::class)
    fun verify(plainText: String, signature: String?, publicKey: PublicKey?): Boolean {
        val publicSignature = Signature.getInstance(SIGNATURE_ALGORITHM)
        publicSignature.initVerify(publicKey)
        publicSignature.update(plainText.toByteArray(StandardCharsets.UTF_8))
        val signatureBytes = Base64.decode(signature, Base64.NO_WRAP)
        return publicSignature.verify(signatureBytes)
    }
}

服务端：java 1 public class RSAUtil { 2

    private static String privateKey = "***************";

    @Value("${check.sign.uri:#}")
    private String checkSignUri;

    @Autowired
    @Qualifier("shua-kxctJedisClusterClient")
    private JedisClusterClient jedisClusterClient;

    //生成秘钥对
//    public static KeyPair getKeyPair() throws Exception {
//        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
//        keyPairGenerator.initialize(512);
//        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编码后的私钥转换成PrivateKey对象
    private 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 boolean checkSign(long userId,String sign,String uri){
        /**核心校验算法**/
    }

    private String decrypt(String cipherText, PrivateKey privateKey) throws Exception {
        byte[] bytes = Base64.getDecoder().decode(cipherText);

        Cipher decriptCipher = Cipher.getInstance("RSA");
        decriptCipher.init(Cipher.DECRYPT_MODE, privateKey);

        return new String(decriptCipher.doFinal(bytes), "UTF-8");
    }

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

核心校验算法逻辑：

　　1、记录最新一次请求成功的签名和时间戳，校验本次请求中的签名是否是上一次使用过的签名

       2、时间校验，为了防止恶意用户使用之前的签名交替请求，添加时间校验，也就是只有顺序的时间戳能通过校验

       3、特殊情况：在弱网环境下请求延迟以及异步接口（即前端不等待服务端结果返回）情况下，顺序的时间序列会出现掉队情况（可以想象成每个请求拿着时间令牌排队，上述情况会造成掉队），这是掉队的请求就无法通过校验，所以增加允许的掉队时间跨度。（时间跨度需要根据情况设定）

注意点：在联调过程中出现服务端解密客户端加密签名时报填充方式不一致的错误，客户端在获取Cipher时一定要使用“RSA/ECB/PKCS1Padding”

上线效果：新产品上线三天后dau达到8万，被拦截的签名错误总计757条，主要集中在4个账号身上，说明对普通用户无影响，且能够拦截恶意刷接口行为。如下是拦截日志分布，呈现时间段分布，也说明是被个别账号在某时间点集中刷接口。

                                         

 总结：没有最好的校验算法，适合自己才最重要，多根据具体业务去思考才能更好的提高。