接口鉴权扩展-加密与解密的实践-跨服务的加密解密方式

妖狐艹你老母 2022-11-30 15:42 165阅读 0赞

### 文章目录 ###

*   *  目标
     *  从支付流程中的加密解密 - 看跨服务的加密解密方式
     *   *  支付流程
         *  代码实践：
         *   *  商户端发送支付请求到支付宝
             *  支付宝端接收商户请求并响应
             *  商户端接收支付宝端响应
         *  总结
     *  一些注意点

## 目标 ##

*  了解跨服务的加密解密方式
    
    参考：[Rsa2验签报错【java.security.SignatureException: Signature length not correct】的解决办法][Rsa2_java.security.SignatureException_ Signature length not correct]
    
    [JAVA 实现签名和解签][JAVA]
    
    [支付宝支付流程图][Link 1]
    
    从支付宝SDK的支付流程理解什么是公钥和私钥，什么是加密和数字签名\](https://www.cnblogs.com/wang-yaz/p/11988853.html)

## 从支付流程中的加密解密 - 看跨服务的加密解密方式 ##

参考：[支付宝][Link 2]

[支付宝支付流程图][Link 1]

[从支付宝SDK的支付流程理解什么是公钥和私钥，什么是加密和数字签名][SDK] 非常推荐阅读，对于某些知识的了解可以参阅。

以下的内容，借鉴了支付宝的支付流程，简单的模拟支付流程。其中一部分代码，也是直接使用支付宝开放平台SDK 的代码。

### 支付流程 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center]

最常见的一个例子：[手机网站支付][Link 3] 不清楚的可以看下，支付宝官方的示例。

我们只关注商户和支付宝之间的流转：

简单的理解，分为两方：商户 和 支付宝。商户发送支付请求到支付宝，支付宝做出响应返回给商户。

那么支付宝如果保证，请求和响应的数据，不被泄露篡改呢。看支付宝的文档，可以得知，使用了RSA 或者 RSA2（新出的） 。

支付宝要求商户提供一套RSA 的公钥和私钥，并将公钥提供给支付宝。支付宝本身也有一套公钥和私钥，商户可以获取支付宝的公钥。支付宝要求商户提交数据时， 使用商户自身的私钥对其格式化的数据进行**签名**，在请求支付宝时，携带数据和签名一起请求。当支付宝接受请求后，先使用商户的公钥解密**验签**,验证数据是否一致，再执行具体业务，通过同步通知或者异步通知的方式返回响应结果，响应结果被支付宝的私钥**签名**。商户接受响应数据后，将其响应数据进行**验签**（支付宝公钥）处理，比对数据是否一致，最终拿到数据。

这里会凸显两个关键词：签名 和 验签，下面内容都是支付宝官方文档的说明。

*  签名
    
    即生成签名方（通常为支付宝客户端）将传送的消息用私钥加密的过程。
    
    我的理解： 签名本质上就是对原文信息的加密，不局限于使用RSA非对称加密算法，使用对称加密算法等，也都是适用的。
 *  验签
    
    指验签方（通常为开放平台的服务端）使用公钥对消息进行验证的过程。
    
    我的理解：验签本质上就是对密文信息的解密。

以 JAVA 语言为例，签名和验签的过程请参见下方。

1.  生成签名方（通常为商户）首先将参数放入一个字符串数组 signFields，把参数和值放入一个对象或 map 中，使用 JSONObject 把这个对象转化成 json 对象。然后构建签名原文，在构建签名原文时，需要把参数按照字典（比如 a，b，c）顺序排序（具体排序方法直接调用 JAVA 的 Arrays.sort 方法），最后使用 RSA 的私钥对签名原文进行签名。
2.  验签方（通常为开放平台的服务端）：和生产签名方一样先生成签名原文，然后使用 RSA 的公钥生成签名方传入的签名并通过签名原文验证该签名，验证结果为 true 则验证成功，否则验证未通过。

图示：

*  签名

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center 1]

*  验签

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center 2]

更新的信息可以参阅支付宝的官方文档，支付宝提供了一个生成公钥私钥的工具，可以下载使用[WINDOWS][]

### 代码实践： ###

参考：[ 自行实现签名][Link 4]

场景： 模拟商户跟支付宝的请求流程，重点对签名和验签的代码实践

思路：

*  商户请求数据加签名请求支付宝接口
 *  支付宝接口接收数据验证签名，判断数据是否一致
 *  支付宝调用商户接口，响应数据加签名
 *  商户接口接收数据验证签名，判断数据是否一致

其实 商户的加签名 验证签名 ，跟支付宝是一致。只不过使用两套RSA 公钥私钥。

实践：

部分代码参照： [支付宝sdk][sdk] 的 AlipaySignature.rsaSign 方法

代码参考：[codecopy][] 下的代码

#### 商户端发送支付请求到支付宝 ####

参考：fun.gengzi.codecopy.business.authentication.controller.SecurityInterfaceController payMoney 方法

controller 层：

@ApiOperation(value = "服务与服务之间参数的加密与解密-第一步", notes = "服务与服务之间参数的加密与解密- " +
                "演示一个支付流程（参考支付宝支付流程对于数据的加密与解密）本接口演示商户客户端发送请求到支付宝（不是真正的调用支付宝）")
        @ApiImplicitParams({ 
                @ApiImplicitParam(name = "OrderInfoEntity", value = "请求参数实体", required = true)})
        @ApiResponses({ @ApiResponse(code = 200, message = "\t{\n" +
                "\t \"status\": 200,\n" +
                "\t \"info\": {\n" +
                "\t }\n" +
                "\t \"message\": \"success\",\n" +
                "\t}\n")})
        @PostMapping("/payMoney")
        @ResponseBody
        public ReturnData payMoney(@RequestBody OrderInfoEntity orderInfoEntity) { 
            // 支付流程 分商户和支付宝 两个服务
            // 准备一套商户RSA 私钥公钥，准备一套支付宝 RSA 私钥公钥
            // 将支付宝公钥发给商户，商户公钥发给支付宝
            // 商户准备数据，通过自己的私钥加密，生成签名字段， 发往支付宝
            // 支付宝通过商户的公钥解密，比对请求参数，是否一致，一致后，处理业务
            // 支付宝自身业务处理完，返回数据，使用支付宝私钥加密，生成签名字段，
            // 商户通过支付宝公钥解密，比对响应参数，是否一致，一致后，处理自身业务。
            // 完成
            logger.info("用户请求商户，发起付款");
            logger.info("商户调用支付宝，发起付款");
            securityInterfaceService.sendSignAndDataInfoToZFB(orderInfoEntity);
            ReturnData ret = ReturnData.newInstance();
            ret.setSuccess();
            return ret;
        }

Service 层：

fun.gengzi.codecopy.business.authentication.service.impl.SecurityInterfaceServiceImpl sendSignAndDataInfoToZFB 方法

关注签名操作

/** * 将数据和签名发送至支付宝 * <p> * 筛选并排序 * 获取所有请求参数，不包括字节类型参数，如文件、字节流，剔除 sign 字段，剔除值为空的参数， * 并按照第一个字符的键值 ASCII 码递增排序（字母升序排序）， * 如果遇到相同字符则按照第二个字符的键值 ASCII 码递增排序，以此类推。 * <p> * 拼接 * 将排序后的参数与其对应值，组合成“参数=参数值”的格式，并且把这些参数用 & 字符连接起来，此时生成的字符串为待签名字符串。 * <p> * 以一下部分代码，参考了支付宝提供的sdk 中的源码 * AlipaySignature.rsaSign * * @param orderInfoEntity {@link OrderInfoEntity} 订单信息 * @return */
        @Override
        public Optional<String> sendSignAndDataInfoToZFB(OrderInfoEntity orderInfoEntity) { 
            // 整理请求参数
            // toJSONString 默认情况下属性值为null的字段不会打印
            String biz_content = JSONObject.toJSONString(orderInfoEntity);
            logger.info("请求实体 biz_content : {}", biz_content);
            MustParamEntity mustParamEntity = new MustParamEntity();
            mustParamEntity.setBiz_content(biz_content);
            mustParamEntity.setNotify_url("http://localhost:8089/api/v2/payMoneyBySH");
            mustParamEntity.setTimestamp(String.valueOf(System.currentTimeMillis()));
            // 获取所有请求参数，不包括字节类型参数，如文件、字节流，剔除 sign 字段，剔除值为空的参数
            // 并排序
            TreeMap<String, String> treeMap = mustParamEntity.mustParamEntityToMap(mustParamEntity);
    // treeMap.forEach((k, v) -> { 
    // logger.info("排序后的 key : {} || value {}", k, v);
    // });
     
            if (!treeMap.isEmpty()) { 
                // 需要签名内容
                String signContent = getSignContent(treeMap);
                logger.info("签名内容 signContent : {}", signContent);
                if (StringUtils.isNotBlank(signContent)) { 
                    logger.info("使用商户私钥对参数签名");
                    // 生成签名
                    String sign = createSign(signContent, SecurityInterfaceConstans.MYPRIVATEKEYRSA, SecurityInterfaceConstans.DEFAULT_CHARSET);
                    // 发送请求
                    logger.info("签名 sign : {}", sign);
                    mustParamEntity.setSign(sign);
                }
            }
     
            if (StringUtils.isNoneBlank(mustParamEntity.getSign())) { 
                // 发送请求
                String jsonBody = JSONUtil.parseObj(mustParamEntity, false).toStringPretty();
                String body = HttpRequest.post(SecurityInterfaceConstans.PAYMONEYZFBURL)
                        .body(jsonBody).execute().body();
                return Optional.ofNullable(body);
            }
            return Optional.empty();
        }

获取签名内容：

/** * @param sortedParams * @return */
        public static String getSignContent(Map<String, String> sortedParams) { 
            StringBuilder content = new StringBuilder();
            List<String> keys = new ArrayList<String>(sortedParams.keySet());
            Collections.sort(keys);
            int index = 0;
            for (String key : keys) { 
                String value = sortedParams.get(key);
                if (areNotEmpty(key, value)) { 
                    content.append(index == 0 ? "" : "&").append(key).append("=").append(value);
                    index++;
                }
            }
            return content.toString();
        }

生成签名：

/** * 生成签名 * * @param content 加签内容 * @param privateKey 商户私钥 * @param charset 字符集 默认 uft-8 * @return */
        private String createSign(String content, String privateKey, String charset) { 
            try { 
                if (StringUtils.isEmpty(content)) { 
                    throw new RrException("待签名内容不可为空");
                }
                if (StringUtils.isEmpty(privateKey)) { 
                    throw new RrException("私钥不可为空");
                }
                if (StringUtils.isEmpty(charset)) { 
                    charset = SecurityInterfaceConstans.DEFAULT_CHARSET;
                }
                return doSign(content, charset, privateKey);
            } catch (Exception e) { 
                String errorMessage = "RSA 签名遭遇异常，请检查私钥格式是否正确。" + e.getMessage() +
                        " content=" + content + "，charset=" + charset + "，privateKeySize=" + privateKey.length();
                throw new RrException(errorMessage, e);
            }
        }
     
    
     
      /** * @param content 需要加密的内容 * @param charset 字符集 * @param privateKey 私钥 * @return * @throws Exception */
        protected String doSign(String content, String charset, String privateKey) throws Exception { 
            PrivateKey priKey = getPrivateKeyFromPKCS8(SecurityInterfaceConstans.SIGN_TYPE_RSA,
                    new ByteArrayInputStream(privateKey.getBytes()));
            Signature signature = Signature.getInstance(getSignAlgorithm());
            signature.initSign(priKey);
            if (StringUtils.isEmpty(charset)) { 
                signature.update(content.getBytes());
            } else { 
                signature.update(content.getBytes(charset));
            }
            byte[] signed = signature.sign();
            return new String(Base64.encodeBase64(signed));
        }
     
       public static PrivateKey getPrivateKeyFromPKCS8(String algorithm,
                                                        InputStream ins) throws Exception { 
            if (ins == null || StringUtils.isEmpty(algorithm)) { 
                return null;
            }
            KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
            byte[] encodedKey = StreamUtil.readText(ins).getBytes();
            encodedKey = Base64.decodeBase64(encodedKey);
            return keyFactory.generatePrivate(new PKCS8EncodedKeySpec(encodedKey));
        }

#### 支付宝端接收商户请求并响应 ####

Controller 层：

fun.gengzi.codecopy.business.authentication.controller.SecurityInterfaceController payMoneyByZFB 方法

@ApiOperation(value = "服务与服务之间参数的加密与解密-第二步", notes = "服务与服务之间参数的加密与解密- " +
                "演示一个支付流程（参考支付宝支付流程对于数据的加密与解密）本接口演示支付宝接受商户请求，并回调商户接口")
        @ApiImplicitParams({ 
                @ApiImplicitParam(name = "MustParamEntity", value = "请求参数实体", required = true)})
        @ApiResponses({ @ApiResponse(code = 200, message = "\t{\n" +
                "\t \"status\": 200,\n" +
                "\t \"info\": {\n" +
                "\t }\n" +
                "\t \"message\": \"success\",\n" +
                "\t}\n")})
        @PostMapping("/payMoneyByZFB")
        @ResponseBody
        public ReturnData payMoneyByZFB(@RequestBody MustParamEntity mustParamEntity) { 
            logger.info("支付宝接受商户请求");
            logger.info("mustParamEntity : {}", mustParamEntity.toString());
            logger.info("mustParamEntity to json : {} ", JSONObject.toJSONString(mustParamEntity));
            // 验签
            boolean sign = securityInterfaceService.responseSignAndDataInfoToSH(mustParamEntity);
            if (sign) { 
                logger.info("用户使用支付宝付款");
                String biz_content = mustParamEntity.getBiz_content();
                OrderInfoEntity orderInfoEntity = JSONUtil.toBean(biz_content, OrderInfoEntity.class);
                String total_amount = orderInfoEntity.getTotal_amount();
                BigDecimal bigDecimal = new BigDecimal(total_amount);
                //TODO 修改金额这个参数，响应
                // 手续费
                BigDecimal fee = BigDecimal.valueOf(0.04);
                bigDecimal.add(fee);
                orderInfoEntity.setTotal_amount(bigDecimal.toString());
                String new_biz_content = JSONObject.toJSONString(orderInfoEntity);
                // 回调
                logger.info("完成付款，支付宝回调商户接口，通知商户，用户已经付款");
                securityInterfaceService.sendSignAndDataInfoToSH(mustParamEntity);
            }
            ReturnData ret = ReturnData.newInstance();
            ret.setFailure("error");
            return ret;
        }

Service 层：

fun.gengzi.codecopy.business.authentication.service.impl.SecurityInterfaceServiceImpl responseSignAndDataInfoToSH

关注验签操作

/** * 支付宝校验签名和请求参数，执行业务，重新回调商户的回调地址 * * @param mustParamEntity * @return */
        @Override
        public boolean responseSignAndDataInfoToSH(MustParamEntity mustParamEntity) { 
            if (StringUtils.isBlank(mustParamEntity.getSign())) { 
                throw new RrException("sign 不能为null");
            }
            String sign = mustParamEntity.getSign();
            TreeMap<String, String> treeMap = mustParamEntity.mustParamEntityToMap(mustParamEntity);
            String signContent = getSignContent(treeMap);
            try { 
                logger.info("使用商户公钥验证签名");
                boolean isSuccess = this.parseSign(sign, SecurityInterfaceConstans.DEFAULT_CHARSET, SecurityInterfaceConstans.MYPUBLICKEYRSA, signContent);
                if (isSuccess) { 
                    logger.info("验签成功");
                    return true;
                }
            } catch (Exception e) { 
                e.printStackTrace();
            }
            logger.info("验签失败");
            return false;
        }

验证签名：

/** * 公钥解密 * * @param signStr 签名 * @param charset 字符编码 * @param publicKey 公钥 商户的公钥 * @return * @throws Exception */
        protected boolean parseSign(String signStr, String charset, String publicKey, String content) throws Exception { 
            PublicKey pubkey = getPublicKeyFromX509(SecurityInterfaceConstans.SIGN_TYPE_RSA,
                    new ByteArrayInputStream(publicKey.getBytes()));
            Signature signature = Signature.getInstance(getSignAlgorithm());
            signature.initVerify(pubkey);
            // base64 解码
            byte[] bytes = Base64.decodeBase64(signStr);
            // 加载签名内容
            signature.update(content.getBytes(charset));
            // 验证签名
            if (signature.verify(bytes)) { 
                return true;
            }
            return false;
        }
     
        public static PublicKey getPublicKeyFromX509(String algorithm, InputStream ins) throws Exception { 
            if (ins == null || StringUtils.isEmpty(algorithm)) { 
                return null;
            }
            KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
            byte[] encodedKey = StreamUtil.readText(ins).getBytes();
            encodedKey = Base64.decodeBase64(encodedKey);
            return keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
        }

#### 商户端接收支付宝端响应 ####

controller 层

fun.gengzi.codecopy.business.authentication.controller.SecurityInterfaceController payMoneyBySH方法

@ApiOperation(value = "服务与服务之间参数的加密与解密-第三步", notes = "服务与服务之间参数的加密与解密- " +
                "演示一个支付流程（参考支付宝支付流程对于数据的加密与解密）本接口演示商户接收支付宝请求，完成对自己的业务处理")
        @ApiImplicitParams({ 
                @ApiImplicitParam(name = "MustParamEntity", value = "请求参数实体", required = true)})
        @ApiResponses({ @ApiResponse(code = 200, message = "\t{\n" +
                "\t \"status\": 200,\n" +
                "\t \"info\": {\n" +
                "\t }\n" +
                "\t \"message\": \"success\",\n" +
                "\t}\n")})
        @PostMapping("/payMoneyBySH")
        @ResponseBody
        public ReturnData payMoneyBySH(@RequestBody MustParamEntity mustParamEntity) { 
            logger.info("商户接收支付宝通知信息");
            ReturnData ret = ReturnData.newInstance();
            logger.info("mustParamEntity : {}", mustParamEntity.toString());
            logger.info("mustParamEntity to json : {} ", JSONObject.toJSONString(mustParamEntity));
            // 验签
            boolean sign = securityInterfaceService.responseSignAndDataInfoToZFB(mustParamEntity);
            if (sign) { 
                // TODO 验签成功，执行自身业务
                logger.info("为该用户办理业务，发货");
                ret.setSuccess();
                return ret;
            }
            ret.setFailure("失败，请稍后再试！");
            return ret;
        }

验签还是一样的操作

### 总结 ###

对于跨服务之间接口的交互，为了保证数据的安全，可以考虑使用RSA 非对称加密的方式来实现。或者 RSA+AES 实现。

## 一些注意点 ##

*  注意私钥加密 和 公钥解密 的代码
    
    都使用base64 编码和解码，因为RSA 加密和解密，一般返回都是byte\[\]。
    
    getPrivateKeyFromPKCS8 私钥
    
    getPublicKeyFromX509 公钥
 *  微信支付流程与支付宝支付流程的区别
    
    参考：[微信支付流程与支付宝支付流程的区别][SDK]
    
    **两者生成数字签名的加密算法不同：微信支付使用MD5加密算法生成数字签名的，而支付宝支付使用RSA加密算法生成数字签名的。**（可见数字签名就是一个加密信息，并不是说只有某种特定的加密方法才能生成数字签名，只要是加密算法就能生成数字签名）
    
    介绍一下微信支付数字签名的生成的加验签流程：
    
     *  我们服务端加签：
        
         *  数字签名=MD5加密（原明文订单信息+该应用的Api密钥）
         *  发起请求的订单信息=原明文订单信息后面拼接上数字签名
     *  \---->传输---->
     *  微信服务端验签：
        
         *  从发起请求的订单信息截取原明文订单信息和数字签名
         *  用来验签的数字签名=MD5加密（原明文订单信息+该应用的Api密钥）
         *  将用来验签的数字签名和数字签名对比，如果一样就说明是指定商户发起的请求，而不是坏蛋模拟的。
    
    可见，这里通过MD5加密也达到了加签验签的效果，\*\*验签的关键参数就是该应用的Api密钥，\*\*这个东西是在我们申请微信支付功能的时候，在平台上自己填写的一个32为的字符串，因此只有我们商户端和微信两者知道的，这样就用一个Api密钥达到了类似支付宝验签那样公钥私钥的效果。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center 3]

[Rsa2_java.security.SignatureException_ Signature length not correct]: https://www.cnblogs.com/caoweixiong/p/10782434.html
[JAVA]: https://blog.csdn.net/lll350203041/article/details/41482017
[Link 1]: https://blog.csdn.net/qq_42120002/article/details/81637412
[Link 2]: https://opendocs.alipay.com/open/291/introduce
[SDK]: https://www.cnblogs.com/wang-yaz/p/11988853.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/e71fb93bf4c14436a048082bf54bca08.png
[Link 3]: https://opendocs.alipay.com/open/203/105288
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/f3a9ad01f07f4b0daf8bd14159140d47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/fc4f6e11181b43a5a0aeeaf4ed088fbe.png
[WINDOWS]: https://ideservice.alipay.com/ide/getPluginUrl.htm?clientType=assistant&platform=win&channelType=WEB
[Link 4]: https://opendocs.alipay.com/open/291/106118
[sdk]: https://opendocs.alipay.com/open/54/103419
[codecopy]: https://github.com/gengzi/codecopy/tree/master/src/main/java/fun/gengzi/codecopy/business/authentication
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/7e4fed21841248a7852d77d324b00b68.png