签名与验签

本章节主要介绍百度收银台使用的双向RSA加密签名规则与相关示例。

基本限定

1.统一字符集：UTF-8 ；
百度收银台接口中的所有参数字符集均保持为 UTF-8 ，与收银台交互接入或者计算签名时，要统一使用 UTF-8 ，暂不支持其他字符集，请接入业务方自行转换；
2.请求接口的参数列表均为字符串类型键值对；
3.键值中如果为复杂数据类型，比如结构体、数组、对象都必须先转化为 JSON 结构字符串；
4.参数中包含汉字的部分，需要做 URLEncode 处理。

签名规则

1.排除参数列表中名为 sign 和 sign_type 的参数；
2.将剩余参数按参数名字典序正序排列；
3.将参数与其对应的值使用 “=” 连接，组成参数字符串，将参数字符串按排序结果，使用 “&” 连接，组成待签名字符串；
4.将待签名字符串和业务方私钥使用 SHA1WithRSA 签名算法得出最终签名。

签名计算过程示例

使用密钥生成中的示例公私钥来做计算演示。

1.初始请求业务参数

参数名示例取值
appKeyMMMabc
dealId470193086
tpOrderId3028903626
totalAmount11300

2.生成待签名字符串

  1. appKey=MMMabc&dealId=470193086&totalAmount=11300&tpOrderId=3028903626

3.生成最终签名串

  1. TN0ZNPyQeTnPjCN5hUa7JwrXOhR8uDASXPazidVQHFSiGCH5aouBkVvJxtf8PeqzGYWAASwS2oOt2eJfunzC5dTFd/pWJeJToMgCSgRY7KtQUCCDnMrtpqiMAf+dLiXps3HpWhVB4CK6MXfHc64ejP5a2fu5bg8B0BTcHrqaGc0=

4.签名的完整请求参数

参数名示例取值
appKeyMMMabc
dealId470193086
tpOrderId3028903626
totalAmount11300
rsaSignTN0ZNPyQeTnPjCN5hUa7JwrXOhR8uDASXPazidVQHFSiGCH5aouBkVvJxtf8PeqzGYWAASwS2oOt2eJfunzC5dTFd/pWJeJToMgCSgRY7KtQUCCDnMrtpqiMAf+dLiXps3HpWhVB4CK6MXfHc64ejP5a2fu5bg8B0BTcHrqaGc0=

签名工具参考代码

  • PHP签名工具类
  1. <?php
  3. // 通用签名工具，基于openssl扩展，提供使用私钥生成签名和使用公钥验证签名的接口
  4. class RSASign
  5. {
  7.     /**
  8.      * @desc 使用私钥生成签名字符串
  9.      * @param array $assocArr 入参数组
  10.      * @param string $rsaPriKeyStr 私钥原始字符串，不含PEM格式前后缀
  11.      * @return string 签名结果字符串
  12.      * @throws Exception
  13.      */
  14.     public static function sign(array $assocArr, $rsaPriKeyStr)
  15.     {
  16.         $sign = '';
  17.         if (empty($rsaPriKeyStr) || empty($assocArr)) {
  18.             return $sign;
  19.         }
  21.         if (!function_exists('openssl_pkey_get_private') || !function_exists('openssl_sign')) {
  22.             throw new Exception("openssl扩展不存在");
  23.         }
  25.         $rsaPriKeyPem = self::convertRSAKeyStr2Pem($rsaPriKeyStr, 1);
  27.         $priKey = openssl_pkey_get_private($rsaPriKeyPem);
  29.         if (isset($assocArr['sign'])) {
  30.             unset($assocArr['sign']);
  31.         }
  32.         // 参数按字典顺序排序
  33.         ksort($assocArr); 
  35.         $parts = array();
  36.         foreach ($assocArr as $k => $v) {
  37.             $parts[] = $k . '=' . $v;
  38.         }
  39.         $str = implode('&', $parts);
  41.         openssl_sign($str, $sign, $priKey);
  42.         openssl_free_key($priKey);
  44.         return base64_encode($sign);
  45.     }
  47.     /**
  48.      * @desc 使用公钥校验签名
  49.      * @param array $assocArr 入参数据，签名属性名固定为rsaSign
  50.      * @param string $rsaPubKeyStr 公钥原始字符串，不含PEM格式前后缀
  51.      * @return bool true 验签通过|false 验签不通过
  52.      * @throws Exception
  53.      */
  54.     public static function checkSign(array $assocArr, $rsaPubKeyStr)
  55.     {
  56.         if (!isset($assocArr['rsaSign']) || empty($assocArr) || empty($rsaPubKeyStr)) {
  57.             return false;
  58.         }
  60.         if (!function_exists('openssl_pkey_get_public') || !function_exists('openssl_verify')) {
  61.             throw new Exception("openssl扩展不存在");
  62.         }
  64.         $sign = $assocArr['rsaSign'];
  65.         unset($assocArr['rsaSign']);
  67.         if (empty($assocArr)) {
  68.             return false;
  69.         }
  70.         // 参数按字典顺序排序
  71.         ksort($assocArr); 
  73.         $parts = array();
  74.         foreach ($assocArr as $k => $v) {
  75.             $parts[] = $k . '=' . $v;
  76.         }
  77.         $str = implode('&', $parts);
  79.         $sign = base64_decode($sign);
  81.         $rsaPubKeyPem = self::convertRSAKeyStr2Pem($rsaPubKeyStr);
  82.         $pubKey = openssl_pkey_get_public($rsaPubKeyPem);
  84.         $result = (bool)openssl_verify($str, $sign, $pubKey);
  85.         openssl_free_key($pubKey);
  87.         return $result;
  88.     }
  91.     /**
  92.      * @desc 将密钥由字符串（不换行）转为PEM格式
  93.      * @param string $rsaKeyStr 原始密钥字符串
  94.      * @param int $keyType 0 公钥|1 私钥，默认0
  95.      * @return string PEM格式密钥
  96.      * @throws Exception
  97.      */
  98.     public static function convertRSAKeyStr2Pem($rsaKeyStr, $keyType = 0)
  99.     {
  101.         $pemWidth = 64;
  102.         $rsaKeyPem = '';
  104.         $begin = '-----BEGIN ';
  105.         $end = '-----END ';
  106.         $key = ' KEY-----';
  107.         $type = $keyType ? 'PRIVATE' : 'PUBLIC';
  109.         $keyPrefix = $begin . $type . $key;
  110.         $keySuffix = $end . $type . $key;
  112.         $rsaKeyPem .= $keyPrefix . "\n";
  113.         $rsaKeyPem .= wordwrap($rsaKeyStr, $pemWidth, "\n", true) . "\n";
  114.         $rsaKeyPem .= $keySuffix;
  116.         if (!function_exists('openssl_pkey_get_public') || !function_exists('openssl_pkey_get_private')) {
  117.             return false;
  118.         }
  120.         if ($keyType == 0 && false == openssl_pkey_get_public($rsaKeyPem)) {
  121.             return false;
  122.         }
  124.         if ($keyType == 1 && false == openssl_pkey_get_private($rsaKeyPem)) {
  125.             return false;
  126.         }
  128.         return $rsaKeyPem;
  129.     }
  131. }
  • Java签名工具类
  1. /*
  2.  * Copyright (C) 2020 Baidu, Inc. All Rights Reserved.
  3.  */
  4. package com.baidu.*;
  6. import static org.springframework.util.Assert.isTrue;
  7. import static org.springframework.util.Assert.notNull;
  9. import java.io.UnsupportedEncodingException;
  10. import java.net.URLEncoder;
  11. import java.security.KeyFactory;
  12. import java.security.NoSuchAlgorithmException;
  13. import java.security.PrivateKey;
  14. import java.security.PublicKey;
  15. import java.security.Signature;
  16. import java.security.spec.InvalidKeySpecException;
  17. import java.security.spec.PKCS8EncodedKeySpec;
  18. import java.security.spec.X509EncodedKeySpec;
  19. import java.util.Base64;
  20. import java.util.Comparator;
  21. import java.util.Map;
  22. import java.util.TreeMap;
  24. import org.springframework.util.CollectionUtils;
  25. import org.springframework.util.StringUtils;
  27. // 百度收银台双向RSA签名工具，JDK版本要求：1.8+
  28. public class RSASign {
  30.     private static final String CHARSET = "UTF-8";
  31.     private static final String SIGN_TYPE_RSA = "RSA";
  32.     private static final String SIGN_ALGORITHMS = "SHA1WithRSA";
  33.     private static final String SIGN_KEY = "rsaSign";
  35.     /**
  36.      * 使用私钥生成签名字符串
  37.      *
  38.      * @param params     待签名参数集合
  39.      * @param privateKey 私钥原始字符串
  40.      *
  41.      * @return 签名结果字符串
  42.      *
  43.      * @throws Exception
  44.      */
  45.     public static String sign(Map<String, Object> params, String privateKey) throws Exception {
  46.         isTrue(!CollectionUtils.isEmpty(params), "params is required");
  47.         notNull(privateKey, "privateKey is required");
  49.         String signContent = signContent(params);
  51.         Signature signature = Signature.getInstance(SIGN_ALGORITHMS);
  52.         signature.initSign(getPrivateKeyPKCS8(privateKey));
  53.         signature.update(signContent.getBytes(CHARSET));
  54.         byte[] signed = signature.sign();
  56.         return new String(Base64.getEncoder().encode(signed));
  57.     }
  59.     /**
  60.      * 使用公钥校验签名
  61.      *
  62.      * @param params    入参数据，签名属性名固定为rsaSign
  63.      * @param publicKey 公钥原始字符串
  64.      *
  65.      * @return true 验签通过 | false 验签不通过
  66.      *
  67.      * @throws Exception
  68.      */
  69.     public static boolean checkSign(Map<String, Object> params, String publicKey) throws Exception {
  70.         isTrue(!CollectionUtils.isEmpty(params), "params is required");
  71.         notNull(publicKey, "publicKey is required");
  73.         // sign & content
  74.         String content = signContent(params);
  75.         String rsaSign = params.get(SIGN_KEY).toString();
  77.         // verify
  78.         Signature signature = Signature.getInstance(SIGN_ALGORITHMS);
  79.         signature.initVerify(getPublicKeyX509(publicKey));
  80.         signature.update(content.getBytes(CHARSET));
  82.         return signature.verify(Base64.getDecoder().decode(rsaSign.getBytes(CHARSET)));
  83.     }
  85.     /**
  86.      * 对输入参数进行key过滤排序和字符串拼接
  87.      *
  88.      * @param params 待签名参数集合
  89.      *
  90.      * @return 待签名内容
  91.      *
  92.      * @throws UnsupportedEncodingException
  93.      */
  94.     private static String signContent(Map<String, Object> params) throws UnsupportedEncodingException {
  95.         Map<String, String> sortedParams = new TreeMap<>(Comparator.naturalOrder());
  96.         for (Map.Entry<String, Object> entry : params.entrySet()) {
  97.             String key = entry.getKey();
  98.             if (legalKey(key)) {
  99.                 String value =
  100.                         entry.getValue() == null ? null : URLEncoder.encode(entry.getValue().toString(), CHARSET);
  101.                 sortedParams.put(key, value);
  102.             }
  103.         }
  105.         StringBuilder builder = new StringBuilder();
  106.         if (!CollectionUtils.isEmpty(sortedParams)) {
  107.             for (Map.Entry<String, String> entry : sortedParams.entrySet()) {
  108.                 builder.append(entry.getKey());
  109.                 builder.append("=");
  110.                 builder.append(entry.getValue());
  111.                 builder.append("&");
  112.             }
  113.             builder.deleteCharAt(builder.length() - 1);
  114.         }
  115.         return builder.toString();
  116.     }
  118.     /**
  119.      * 将公钥字符串进行Base64 decode之后，生成X509标准公钥
  120.      *
  121.      * @param publicKey 公钥原始字符串
  122.      *
  123.      * @return X509标准公钥
  124.      *
  125.      * @throws InvalidKeySpecException
  126.      * @throws NoSuchAlgorithmException
  127.      */
  128.     private static PublicKey getPublicKeyX509(String publicKey) throws InvalidKeySpecException,
  129.             NoSuchAlgorithmException, UnsupportedEncodingException {
  130.         if (StringUtils.isEmpty(publicKey)) {
  131.             return null;
  132.         }
  133.         KeyFactory keyFactory = KeyFactory.getInstance(SIGN_TYPE_RSA);
  134.         byte[] decodedKey = Base64.getDecoder().decode(publicKey.getBytes(CHARSET));
  135.         return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));
  136.     }
  138.     /**
  139.      * 将私钥字符串进行Base64 decode之后，生成PKCS #8标准的私钥
  140.      *
  141.      * @param privateKey 私钥原始字符串
  142.      *
  143.      * @return PKCS #8标准的私钥
  144.      *
  145.      * @throws Exception
  146.      */
  147.     private static PrivateKey getPrivateKeyPKCS8(String privateKey) throws Exception {
  148.         if (StringUtils.isEmpty(privateKey)) {
  149.             return null;
  150.         }
  151.         KeyFactory keyFactory = KeyFactory.getInstance(SIGN_TYPE_RSA);
  152.         byte[] decodedKey = Base64.getDecoder().decode(privateKey.getBytes(CHARSET));
  153.         return keyFactory.generatePrivate(new PKCS8EncodedKeySpec(decodedKey));
  154.     }
  156.     /**
  157.      * 有效的待签名参数key值
  158.      * 非空、且非签名字段
  159.      *
  160.      * @param key 待签名参数key值
  161.      *
  162.      * @return true | false
  163.      */
  164.     private static boolean legalKey(String key) {
  165.         return StringUtils.hasText(key) && !SIGN_KEY.equalsIgnoreCase(key);
  166.     }
  168. }

验证

加签逻辑验证

开发者实现加签逻辑之后，使用计算示例中步骤 1 的初始请求参数作为输入，结合密钥生成中的示例私钥，进行 RSA 签名的生成，如果结果与步骤 3 中最终签名串一致，说明加签逻辑正确。

验签逻辑验证

使用计算示例中步骤 4 完整请求参数作为输入，结合密钥生成中的示例公钥，进行 RSA 签名的 check ，返回 true 则说明验签逻辑正确。