更新

src/main/java/cn/qg/qaplatform/mock/encrypt/factory/EncryptConvertor.java

+package cn.qg.qaplatform.mock.encrypt.factory;
+
+public interface EncryptConvertor {
+
+    String encrypt(String response);
+
+    String decrypt(String request);
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/factory/EncryptFactory.java

+package cn.qg.qaplatform.mock.encrypt.factory;
+
+import lombok.extern.slf4j.Slf4j;
+
+
+@Slf4j
+public class EncryptFactory {
+
+    public static EncryptConvertor produce(String type) {
+        if ("yeebao".equals(type)) {
+            return new YeebaoEncryptConvertor();
+        } else {
+            log.info("请输入正确的加密类型类型！");
+            return null;
+        }
+    }
+
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/factory/YeebaoEncryptConvertor.java

+package cn.qg.qaplatform.mock.encrypt.factory;
+
+import cn.qg.qaplatform.mock.encrypt.paycenter.Aes;
+import cn.qg.qaplatform.mock.encrypt.paycenter.Rsa;
+import cn.qg.qaplatform.utils.JsonTransUtils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class YeebaoEncryptConvertor implements EncryptConvertor {
+
+    private final String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBANSBQSc0Hlr+mS7uoIjYS71X2DJ6ZrCcbB1uICqty9QY6W16nZ8tLN/d9k2Z+e2rGG8s7PskpU2T+WuJeDSXs/vpPllG8/tSRVaWcr9EzPaSti3ltSUH0QOLSypZEjTT/slscExj4PMOmQXUXP3gewjNWz1cYRI7dGnKPm+ZFah/AgMBAAECgYB8AcFngz6DkzcI8C+2K6JnJ6/+JPdv8JgWxID45tqfNrphLMB2dwJM0VY+CrCSRNnJZsoT9FqSXtuaKWqAJlbchhPZjupA9RkWFzlGpCQ63/CC71RYYY03eCnc7AIpn52whkjfWG/yf57jKzEwUT+U034uvXdaA+lVvJ0xqpj3gQJBAOmLODjecn450TJbNQaop+7Q5Hz2TUIxbYakzPpcLGv1QYgHa657r7PJ23ZltDBGldMaNTZfqJrtDcq0rTA4lBECQQDo8CcdUhMZ3JbR2UZN0CG8ljMbNWgNWBa37ebE3ZG5yYldc7zY9US/+/7lhxNDqG0saTvM9pJwEc3ccVMvksOPAkEAqq7V+zIQKVJmItBn06MFgNNoei+kTUFEk8f0CvG8gXYwW5NYzp+UzOg1HbW82B9uNmeMBl4pInknwEMF5B0lkQJAdRxQPgCGk+kAdo6LNxHd9Ed7eEF4h8Ty3xQfgnh3DHYTtsU6e8WMBA24kENB3zEtejeKFjkdVHTPD/Z1wSRDZwJAAvNuq0YuRDsESOAerkBZKonA5CD0M4vHTRqihHrjBohv6yxBU8P7gALrX7qmoaZ3aLmN8wHdOAGTR6LZjQdkoQ==";
+    private String aesKey = null;
+    private String encryptKey = null;
+
+    /**
+     * 易宝加密
+     * @param response
+     * @return
+     */
+    @Override
+    public String encrypt(String response) {
+        try {
+            Map responseMap = JsonTransUtils.strToMap(response);
+            responseMap.put("sign", Rsa.sign(response, privateKey));
+            responseMap.put("data", Aes.encryptToBase64(response, aesKey));
+            return JsonTransUtils.mapToJson(responseMap);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * 易宝解密
+     * @param request Http请求的request
+     * @return
+     */
+    @Override
+    public String decrypt(String request) {
+        try {
+            Map requestMap = JsonTransUtils.strToMap(request);
+            aesKey = Rsa.decrypt((String) requestMap.get("encryptkey"), privateKey);
+            return Aes.decryptFromBase64((String) requestMap.get("data"), aesKey);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/AbstractConvertUtils.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+public abstract class AbstractConvertUtils {
+
+  private AbstractConvertUtils() {
+  }
+
+  public static String toHex(byte input[]) {
+    if (input == null) {
+      return null;
+    }
+    StringBuffer output = new StringBuffer(input.length * 2);
+    for (int i = 0; i < input.length; i++) {
+      int current = input[i] & 0xff;
+      if (current < 16) {
+        output.append("0");
+      }
+      output.append(Integer.toString(current, 16));
+    }
+
+    return output.toString();
+  }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/Aes.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
+import javax.crypto.spec.SecretKeySpec;
+import java.io.UnsupportedEncodingException;
+import java.security.Key;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+
+public class Aes {
+  private static final int KEY_LENGTH = 16;
+
+  /**
+   * 加密
+   *
+   * @param data 需要加密的内容
+   * @param key 加密密码
+   */
+  public static byte[] encrypt(byte[] data, byte[] key) {
+    CheckUtils.notEmpty(data, "data");
+    CheckUtils.notEmpty(key, "key");
+    if (key.length != KEY_LENGTH) {
+      throw new RuntimeException("Invalid Aes key length (must be 16 bytes)");
+    }
+    try {
+      SecretKeySpec secretKey = new SecretKeySpec(key, "Aes");
+      byte[] enCodeFormat = secretKey.getEncoded();
+      SecretKeySpec seckey = new SecretKeySpec(enCodeFormat, "Aes");
+      Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.AES_ALGORITHM);// 创建密码器
+      cipher.init(Cipher.ENCRYPT_MODE, seckey);// 初始化
+      byte[] result = cipher.doFinal(data);
+      return result; // 加密
+    } catch (Exception e) {
+      throw new RuntimeException("encrypt fail!", e);
+    }
+  }
+
+  /**
+   * 解密
+   *
+   * @param data 待解密内容
+   * @param key 解密密钥
+   */
+  public static byte[] decrypt(byte[] data, byte[] key) {
+    CheckUtils.notEmpty(data, "data");
+    CheckUtils.notEmpty(key, "key");
+    if (key.length != KEY_LENGTH) {
+      throw new RuntimeException("Invalid Aes key length (must be 16 bytes)");
+    }
+    try {
+      SecretKeySpec secretKey = new SecretKeySpec(key, "Aes");
+      byte[] enCodeFormat = secretKey.getEncoded();
+      SecretKeySpec seckey = new SecretKeySpec(enCodeFormat, "Aes");
+      Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.AES_ALGORITHM);// 创建密码器
+      cipher.init(Cipher.DECRYPT_MODE, seckey);// 初始化
+      byte[] result = cipher.doFinal(data);
+      return result; // 加密
+    } catch (Exception e) {
+      throw new RuntimeException("decrypt fail!", e);
+    }
+  }
+
+  public static String encryptToBase64(String data, String key) {
+    try {
+      byte[] valueByte = encrypt(data.getBytes(ConfigureEncryptAndDecrypt.CHAR_ENCODING),
+          key.getBytes(ConfigureEncryptAndDecrypt.CHAR_ENCODING));
+      return new String(Base64.encode(valueByte));
+    } catch (UnsupportedEncodingException e) {
+      throw new RuntimeException("encrypt fail!", e);
+    }
+  }
+
+  public static String decryptFromBase64(String data, String key) {
+    try {
+      byte[] originalData = Base64.decode(data.getBytes());
+      byte[] valueByte =
+          decrypt(originalData, key.getBytes(ConfigureEncryptAndDecrypt.CHAR_ENCODING));
+      return new String(valueByte, ConfigureEncryptAndDecrypt.CHAR_ENCODING);
+    } catch (UnsupportedEncodingException e) {
+      throw new RuntimeException("decrypt fail!", e);
+    }
+  }
+
+  public static String encryptWithKeyBase64(String data, String key) {
+    try {
+      byte[] valueByte = encrypt(data.getBytes(ConfigureEncryptAndDecrypt.CHAR_ENCODING),
+          Base64.decode(key.getBytes()));
+      return new String(Base64.encode(valueByte));
+    } catch (UnsupportedEncodingException e) {
+      throw new RuntimeException("encrypt fail!", e);
+    }
+  }
+
+  public static String decryptWithKeyBase64(String data, String key) {
+    try {
+      byte[] originalData = Base64.decode(data.getBytes());
+      byte[] valueByte = decrypt(originalData, Base64.decode(key.getBytes()));
+      return new String(valueByte, ConfigureEncryptAndDecrypt.CHAR_ENCODING);
+    } catch (UnsupportedEncodingException e) {
+      throw new RuntimeException("decrypt fail!", e);
+    }
+  }
+
+  public static byte[] genarateRandomKey() {
+    KeyGenerator keygen = null;
+    try {
+      keygen = KeyGenerator.getInstance(ConfigureEncryptAndDecrypt.AES_ALGORITHM);
+    } catch (NoSuchAlgorithmException e) {
+      throw new RuntimeException(" genarateRandomKey fail!", e);
+    }
+    SecureRandom random = new SecureRandom();
+    keygen.init(random);
+    Key key = keygen.generateKey();
+    return key.getEncoded();
+  }
+
+  public static String genarateRandomKeyWithBase64() {
+    return new String(Base64.encode(genarateRandomKey()));
+  }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/CheckUtils.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+import java.lang.reflect.Array;
+import java.util.Collection;
+import java.util.Map;
+
+public class CheckUtils {
+
+  /**
+   * 验证对象是否为NULL,空字符串，空数组，空的Collection或Map(只有空格的字符串也认为是空串)
+   *
+   * @param obj 被验证的对象
+   * @param message 异常信息
+   */
+  @SuppressWarnings("rawtypes")
+  public static void notEmpty(Object obj, String message) {
+    if (obj == null) {
+      throw new IllegalArgumentException(message + " must be specified");
+    }
+    if (obj instanceof String && obj.toString().trim().length() == 0) {
+      throw new IllegalArgumentException(message + " must be specified");
+    }
+    if (obj.getClass().isArray() && Array.getLength(obj) == 0) {
+      throw new IllegalArgumentException(message + " must be specified");
+    }
+    if (obj instanceof Collection && ((Collection) obj).isEmpty()) {
+      throw new IllegalArgumentException(message + " must be specified");
+    }
+    if (obj instanceof Map && ((Map) obj).isEmpty()) {
+      throw new IllegalArgumentException(message + " must be specified");
+    }
+  }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/ConfigureEncryptAndDecrypt.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+public class ConfigureEncryptAndDecrypt {
+  public static final String CHAR_ENCODING = "UTF-8";
+  public static final String AES_ALGORITHM = "Aes/ECB/PKCS5Padding";
+  public static final String RSA_ALGORITHM = "Rsa/ECB/PKCS1Padding";
+}
+

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/Digest.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.UnsupportedEncodingException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+
+@Slf4j
+public class Digest {
+  public static final String ENCODE = "UTF-8";
+
+  public static String signMD5(String aValue, String encoding) {
+    try {
+      byte[] input = aValue.getBytes(encoding);
+      MessageDigest md = MessageDigest.getInstance("MD5");
+      return AbstractConvertUtils.toHex(md.digest(input));
+    } catch (NoSuchAlgorithmException e) {
+      log.error("{}", e);
+      return null;
+    } catch (UnsupportedEncodingException e) {
+      log.error("{}", e);
+      return null;
+    }
+  }
+
+  public static String hmacSign(String aValue) {
+    try {
+      byte[] input = aValue.getBytes();
+      MessageDigest md = MessageDigest.getInstance("MD5");
+      return AbstractConvertUtils.toHex(md.digest(input));
+    } catch (NoSuchAlgorithmException e) {
+      log.error("{}", e);
+      return null;
+    }
+  }
+
+  public static String hmacSign(String aValue, String aKey) {
+    return hmacSign(aValue, aKey, ENCODE);
+  }
+
+  public static String hmacSign(String aValue, String aKey, String encoding) {
+    byte k_ipad[] = new byte[64];
+    byte k_opad[] = new byte[64];
+    byte keyb[];
+    byte value[];
+    try {
+      keyb = aKey.getBytes(encoding);
+      value = aValue.getBytes(encoding);
+    } catch (UnsupportedEncodingException e) {
+      keyb = aKey.getBytes();
+      value = aValue.getBytes();
+    }
+    Arrays.fill(k_ipad, keyb.length, 64, (byte) 54);
+    Arrays.fill(k_opad, keyb.length, 64, (byte) 92);
+    for (int i = 0; i < keyb.length; i++) {
+      k_ipad[i] = (byte) (keyb[i] ^ 0x36);
+      k_opad[i] = (byte) (keyb[i] ^ 0x5c);
+    }
+
+    MessageDigest md = null;
+    try {
+      md = MessageDigest.getInstance("MD5");
+    } catch (NoSuchAlgorithmException e) {
+      log.error("{}", e);
+      return null;
+    }
+    md.update(k_ipad);
+    md.update(value);
+    byte dg[] = md.digest();
+    md.reset();
+    md.update(k_opad);
+    md.update(dg, 0, 16);
+    dg = md.digest();
+    return AbstractConvertUtils.toHex(dg);
+  }
+
+  public static String hmacSHASign(String aValue, String aKey, String encoding) {
+    byte k_ipad[] = new byte[64];
+    byte k_opad[] = new byte[64];
+    byte keyb[];
+    byte value[];
+    try {
+      keyb = aKey.getBytes(encoding);
+      value = aValue.getBytes(encoding);
+    } catch (UnsupportedEncodingException e) {
+      keyb = aKey.getBytes();
+      value = aValue.getBytes();
+    }
+    Arrays.fill(k_ipad, keyb.length, 64, (byte) 54);
+    Arrays.fill(k_opad, keyb.length, 64, (byte) 92);
+    for (int i = 0; i < keyb.length; i++) {
+      k_ipad[i] = (byte) (keyb[i] ^ 0x36);
+      k_opad[i] = (byte) (keyb[i] ^ 0x5c);
+    }
+
+    MessageDigest md = null;
+    try {
+      md = MessageDigest.getInstance("SHA");
+    } catch (NoSuchAlgorithmException e) {
+      log.error("{}", e);
+      return null;
+    }
+    md.update(k_ipad);
+    md.update(value);
+    byte dg[] = md.digest();
+    md.reset();
+    md.update(k_opad);
+    md.update(dg, 0, 20);
+    dg = md.digest();
+    return AbstractConvertUtils.toHex(dg);
+  }
+
+  public static String digest(String aValue) {
+    return digest(aValue, ENCODE);
+  }
+
+  public static String digest(String aValue, String encoding) {
+    aValue = aValue.trim();
+    byte value[];
+    try {
+      value = aValue.getBytes(encoding);
+    } catch (UnsupportedEncodingException e) {
+      value = aValue.getBytes();
+    }
+    MessageDigest md = null;
+    try {
+      md = MessageDigest.getInstance("SHA");
+    } catch (NoSuchAlgorithmException e) {
+      log.error("{}", e);
+      return null;
+    }
+    return AbstractConvertUtils.toHex(md.digest(value));
+  }
+
+  public static String digest(String aValue, String alg, String encoding) {
+    aValue = aValue.trim();
+    byte value[];
+    try {
+      value = aValue.getBytes(encoding);
+    } catch (UnsupportedEncodingException e) {
+      value = aValue.getBytes();
+    }
+    MessageDigest md = null;
+    try {
+      md = MessageDigest.getInstance(alg);
+    } catch (NoSuchAlgorithmException e) {
+      log.error("{}", e);
+      return null;
+    }
+    return AbstractConvertUtils.toHex(md.digest(value));
+  }
+
+  public static String udpSign(String aValue) {
+    try {
+      byte[] input = aValue.getBytes("UTF-8");
+      MessageDigest md = MessageDigest.getInstance("SHA1");
+      return new String(Base64.encode(md.digest(input)), ENCODE);
+    } catch (Exception e) {
+      return null;
+    }
+  }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/EncryUtil.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.TypeReference;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+
+
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
+@Slf4j
+public class EncryUtil {
+
+  /**
+   * 生成RSA签名
+   */
+  public static String handleRSA(TreeMap<String, Object> map,
+      String privateKey) {
+    StringBuffer sbuffer = new StringBuffer();
+    for (Entry<String, Object> entry : map.entrySet()) {
+      sbuffer.append(entry.getValue());
+    }
+    String signTemp = sbuffer.toString();
+
+    String sign = "";
+    if (StringUtils.isNotEmpty(privateKey)) {
+      sign = Rsa.sign(signTemp, privateKey);
+    }
+    return sign;
+  }
+
+  /**
+   * 对易宝支付返回的结果进行验签
+   *
+   * @param data 易宝支付返回的业务数据密文
+   * @param encrypt_key 易宝支付返回的对ybAesKey加密后的密文
+   * @param yibaoPublickKey 易宝支付提供的公钥
+   * @param merchantPrivateKey 商户自己的私钥
+   * @return 验签是否通过
+   * @throws Exception
+   */
+  public static boolean checkDecryptAndSign(String data, String encrypt_key,
+      String yibaoPublickKey, String merchantPrivateKey) {
+
+    /** 1.使用YBprivatekey解开aesEncrypt。 */
+    String AESKey;
+    try {
+      AESKey = Rsa.decrypt(encrypt_key, merchantPrivateKey);
+    } catch (Exception e) {
+      /** AES密钥解密失败 */
+      log.error("{}", e);
+      return false;
+    }
+
+    /** 2.用aeskey解开data。取得data明文 */
+    String realData = Aes.decryptFromBase64(data, AESKey);
+
+    TreeMap<String, String> map = JSON.parseObject(realData,
+        new TypeReference<TreeMap<String, String>>() {
+        });
+
+    /** 3.取得data明文sign。 */
+    String sign = StringUtils.trimToEmpty(map.get("sign"));
+
+    StringBuilder signData = new StringBuilder();
+    for (Entry<String, String> entry : map.entrySet()) {
+      if (StringUtils.equals(entry.getKey(), "sign")) {
+        continue;
+      }
+      signData.append(entry.getValue() == null ? "" : entry.getValue());
+    }
+
+    /** 5. result为true时表明验签通过 */
+    String str = signData.toString();
+
+    return Rsa.checkSign(str, sign,
+        yibaoPublickKey);
+  }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/RandomUtil.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+import java.security.SecureRandom;
+
+public class RandomUtil {
+
+  public static final SecureRandom random = new SecureRandom();
+
+  public static String getRandom(int length) {
+    StringBuilder ret = new StringBuilder();
+    for (int i = 0; i < length; i++) {
+      boolean isChar = (random.nextInt(2) % 2 == 0);// 输出字母还是数字
+      if (isChar) { // 字符串
+        int choice = random.nextInt(2) % 2 == 0 ? 65 : 97; // 取得大写字母还是小写字母
+        ret.append((char) (choice + random.nextInt(26)));
+      } else { // 数字
+        ret.append(Integer.toString(random.nextInt(10)));
+      }
+    }
+    return ret.toString();
+  }
+}

src/main/java/cn/qg/qaplatform/mock/encrypt/paycenter/Rsa.java

+package cn.qg.qaplatform.mock.encrypt.paycenter;
+
+import java.math.BigInteger;
+import java.security.Key;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.SecureRandom;
+import java.security.Signature;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.HashMap;
+import java.util.Map;
+import javax.crypto.Cipher;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+public class Rsa {
+    /**
+     * 指定key的大小
+     */
+    private static int KEYSIZE = 1024;
+
+    /**
+     * 生成密钥对
+     */
+    public static Map<String, String> generateKeyPair() throws Exception {
+        /** RSA算法要求有一个可信任的随机数源 */
+        SecureRandom sr = new SecureRandom();
+        /** 为RSA算法创建一个KeyPairGenerator对象 */
+        KeyPairGenerator kpg = KeyPairGenerator.getInstance("Rsa");
+        /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
+        kpg.initialize(KEYSIZE, sr);
+        /** 生成密匙对 */
+        KeyPair kp = kpg.generateKeyPair();
+        /** 得到公钥 */
+        Key publicKey = kp.getPublic();
+        byte[] publicKeyBytes = publicKey.getEncoded();
+        String pub = new String(Base64.encodeBase64(publicKeyBytes),
+                ConfigureEncryptAndDecrypt.CHAR_ENCODING);
+        /** 得到私钥 */
+        Key privateKey = kp.getPrivate();
+        byte[] privateKeyBytes = privateKey.getEncoded();
+        String pri = new String(Base64.encodeBase64(privateKeyBytes),
+                ConfigureEncryptAndDecrypt.CHAR_ENCODING);
+
+        Map<String, String> map = new HashMap<String, String>();
+        map.put("publicKey", pub);
+        map.put("privateKey", pri);
+        RSAPublicKey rsp = (RSAPublicKey) kp.getPublic();
+        BigInteger bint = rsp.getModulus();
+        byte[] b = bint.toByteArray();
+        byte[] deBase64Value = Base64.encodeBase64(b);
+        String retValue = new String(deBase64Value);
+        map.put("modulus", retValue);
+        return map;
+    }
+
+    /**
+     * 加密方法 source： 源数据
+     */
+    public static String encrypt(String source, String publicKey)
+            throws Exception {
+        Key key = getPublicKey(publicKey);
+        /** 得到Cipher对象来实现对源数据的RSA加密 */
+        Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.RSA_ALGORITHM);
+        cipher.init(Cipher.ENCRYPT_MODE, key);
+        byte[] b = source.getBytes();
+        /** 执行加密操作 */
+        byte[] b1 = cipher.doFinal(b);
+        return new String(Base64.encodeBase64(b1),
+                ConfigureEncryptAndDecrypt.CHAR_ENCODING);
+    }
+
+    /**
+     * 解密算法 cryptograph:密文
+     */
+    public static String decrypt(String cryptograph, String privateKey)
+            throws Exception {
+        Key key = getPrivateKey(privateKey);
+        /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
+        Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.RSA_ALGORITHM);
+        cipher.init(Cipher.DECRYPT_MODE, key);
+        byte[] b1 = Base64.decodeBase64(cryptograph.getBytes());
+        /** 执行解密操作 */
+        byte[] b = cipher.doFinal(b1);
+        return new String(b);
+    }
+
+    /**
+     * 得到公钥
+     *
+     * @param key 密钥字符串（经过base64编码）
+     * @throws Exception
+     */
+    public static PublicKey getPublicKey(String key) throws Exception {
+        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(
+                Base64.decodeBase64(key.getBytes()));
+        KeyFactory keyFactory = KeyFactory.getInstance("Rsa");
+        PublicKey publicKey = keyFactory.generatePublic(keySpec);
+        return publicKey;
+    }
+
+    /**
+     * 得到私钥
+     *
+     * @param key 密钥字符串（经过base64编码）
+     * @throws Exception
+     */
+    public static PrivateKey getPrivateKey(String key) throws Exception {
+        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(
+                Base64.decodeBase64(key.getBytes()));
+        KeyFactory keyFactory = KeyFactory.getInstance("Rsa");
+        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
+        return privateKey;
+    }
+
+    public static String sign(String content, String privateKey) {
+        String charset = ConfigureEncryptAndDecrypt.CHAR_ENCODING;
+        try {
+            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(
+                    Base64.decodeBase64(privateKey.getBytes()));
+            KeyFactory keyf = KeyFactory.getInstance("Rsa");
+            PrivateKey priKey = keyf.generatePrivate(priPKCS8);
+
+            Signature signature = Signature.getInstance("SHA1WithRSA");
+
+            signature.initSign(priKey);
+            signature.update(content.getBytes(charset));
+
+            byte[] signed = signature.sign();
+
+            return new String(Base64.encodeBase64(signed));
+        } catch (Exception e) {
+
+        }
+
+        return null;
+    }
+
+    public static boolean checkSign(String content, String sign, String publicKey) {
+        try {
+            KeyFactory keyFactory = KeyFactory.getInstance("Rsa");
+            byte[] encodedKey = Base64.decode2(publicKey);
+            PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
+
+            Signature signature = Signature
+                    .getInstance("SHA1WithRSA");
+
+            signature.initVerify(pubKey);
+            signature.update(content.getBytes("utf-8"));
+
+            boolean bverify = signature.verify(Base64.decode2(sign));
+            return bverify;
+        } catch (Exception e) {
+            log.error("{}", e);
+        }
+
+        return false;
+    }
+}

src/main/java/cn/qg/qaplatform/mock/interceptor/PayInterceptor.java

 package cn.qg.qaplatform.mock.interceptor;
 
 import cn.qg.qaplatform.config.SwitchDataSource;
+import cn.qg.qaplatform.mock.encrypt.factory.EncryptConvertor;
+import cn.qg.qaplatform.mock.encrypt.factory.EncryptFactory;
+import cn.qg.qaplatform.mock.encrypt.paycenter.Aes;
+import cn.qg.qaplatform.mock.encrypt.paycenter.Rsa;
 import cn.qg.qaplatform.mock.entity.Mock;
 import cn.qg.qaplatform.mock.mapper.MockMapper;
+import cn.qg.qaplatform.utils.JsonTransUtils;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.lang.Nullable;
 import org.springframework.web.servlet.HandlerInterceptor;
 import org.springframework.web.servlet.ModelAndView;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+import java.io.BufferedReader;
+import java.io.IOException;
 import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.Map;
 
 @Slf4j
 public class PayInterceptor implements HandlerInterceptor {
@@ -20,10 +30,29 @@ public class PayInterceptor implements HandlerInterceptor {
     @Autowired
     MockMapper mockMapper;
 
+    @Value("${namespace}")
+    private String namespace;
+
+    /**
+     * 获取HttpServletRequest的body
+     * @param request HttpServletRequest
+     * @return
+     * @throws IOException
+     */
+    private String getRequestBody(HttpServletRequest request) throws IOException {
+        BufferedReader br = request.getReader();
+        String str;
+        StringBuilder wholeStr = new StringBuilder();
+        while((str = br.readLine()) != null){
+            wholeStr.append(str);
+        }
+        return wholeStr.toString();
+    }
+
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
             throws Exception {
-        SwitchDataSource.dataSourceSwitch("pre", "qa");
+        SwitchDataSource.dataSourceSwitch(namespace, "qa");
         String uri = request.getRequestURI().substring(5);
         QueryWrapper<Mock> queryWrapper = new QueryWrapper<>();
         queryWrapper.eq("url", uri);
@@ -31,12 +60,24 @@ public class PayInterceptor implements HandlerInterceptor {
         response.setHeader("Content-type", "application/json;charset=UTF-8");
         response.setCharacterEncoding("UTF-8");
         PrintWriter printWriter = response.getWriter();
+        // 对request进行解密
+        EncryptConvertor encryptConvertor = EncryptFactory.produce("yeebao");
+        Map<String, Object> requestMap = JsonTransUtils.strToMap(encryptConvertor.decrypt(getRequestBody(request)));
+        Map<String, Object> responseMap = new HashMap<>();
         if (mock.getFlag().equals(1)) {
-            printWriter.write(mock.getSuccess());
+            responseMap = JsonTransUtils.strToMap(mock.getSuccess());
         } else if (mock.getFlag().equals(0)) {
-            printWriter.write(mock.getFail());
+            responseMap = JsonTransUtils.strToMap(mock.getFail());
         }
-        // 对请求进行解密TF
+        // 如果response中存在变量，则使用requestMap中对应变量进行替换
+        for (Map.Entry<String, Object> entry: responseMap.entrySet()) {
+            String value = (String) entry.getValue();
+            if (value.startsWith("$request")) {
+                entry.setValue(requestMap.get(value.split("\\.")[1]));
+            }
+        }
+        // 对response加密
+        printWriter.write(encryptConvertor.encrypt(JsonTransUtils.mapToJson(responseMap)));
         return true;
     }
 
@@ -52,4 +93,7 @@ public class PayInterceptor implements HandlerInterceptor {
         log.info("calling afterCompletion");
 
     }
+
+    public static void main(String[] args) {
+    }
 }