package com.nova.sankuai.domain.api.hengyidai;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import lombok.Data;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.io.IOUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.http.*;
|
import org.springframework.http.client.SimpleClientHttpRequestFactory;
|
import org.springframework.stereotype.Component;
|
import org.springframework.web.client.RestTemplate;
|
import sun.misc.BASE64Decoder;
|
import sun.misc.BASE64Encoder;
|
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.security.*;
|
import java.security.interfaces.RSAPrivateKey;
|
import java.security.interfaces.RSAPublicKey;
|
import java.security.spec.PKCS8EncodedKeySpec;
|
import java.security.spec.X509EncodedKeySpec;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
|
/**
|
* RSA 加解密
|
* <p>
|
* 字符串格式的密钥在未在特殊说明情况下都为 BASE64 编码格式<br/>
|
* 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
|
* 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据
|
* 的安全
|
* </P>
|
*
|
* @author kuangxiang
|
* @date 2021/05/19 15:31
|
*/
|
@Slf4j
|
@Component
|
@Data
|
public class HySignUtil {
|
|
|
/**
|
* 本地公钥
|
*/
|
@Value("${hengyidai.conf.local-public-key}")
|
private String local_public_key;
|
|
/**
|
* 本地私钥
|
*/
|
@Value("${hengyidai.conf.local-private-key}")
|
private String local_private_key;
|
|
/**
|
* 第三方公钥
|
*/
|
@Value("${hengyidai.conf.other-public-key}")
|
private String other_public_key;
|
|
/**
|
* 请求地址
|
*/
|
@Value("${hengyidai.conf.api-url}")
|
private String hyPath;
|
|
/**
|
* 产品编码
|
*/
|
@Value("${hengyidai.conf.product-no}")
|
private String productNo;
|
|
/**
|
* 加密算法 RSA
|
*/
|
public static final String KEY_ALGORITHM = "RSA";
|
/**
|
* 签名算法
|
*/
|
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
|
/**
|
* 获取公钥的 key
|
*/
|
private static final String PUBLIC_KEY = "RSAPublicKey";
|
/**
|
* 获取私钥的 key
|
*/
|
private static final String PRIVATE_KEY = "RSAPrivateKey";
|
|
/**
|
* 生成数字签名 sign
|
*
|
* @param data 待加密数据
|
* @param privateKey 私钥(BASE64 编码)
|
* @return
|
* @throws Exception
|
*/
|
public static String sign(String data, String privateKey) throws Exception {
|
byte[] keyBytes = decode(privateKey);
|
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
|
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
|
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
|
signature.initSign(privateK);
|
signature.update(data.getBytes());
|
return encode(signature.sign());
|
}
|
|
/**
|
* 验签
|
*
|
* @param data 已加密数
|
* @param publicKey 公钥(BASE64 编码)
|
* @param sign 数字签
|
* @return
|
* @throws Exception
|
*/
|
public static boolean verify(String data, String publicKey, String sign) throws Exception {
|
byte[] keyBytes = decode(publicKey);
|
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
|
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
|
PublicKey publicK = keyFactory.generatePublic(keySpec);
|
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
|
signature.initVerify(publicK);
|
signature.update(data.getBytes());
|
return signature.verify(decode(sign));
|
}
|
|
/**
|
* 获取私钥
|
*
|
* @param keyMap 密钥对
|
* @return
|
* @throws Exception
|
*/
|
public static String getPrivateKey(Map<String, Object> keyMap)
|
throws Exception {
|
Key key = (Key) keyMap.get(PRIVATE_KEY);
|
return encode(key.getEncoded());
|
}
|
|
/**
|
* 获取公钥
|
*
|
* @param keyMap 密钥对
|
* @return
|
* @throws Exception
|
*/
|
public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
|
Key key = (Key) keyMap.get(PUBLIC_KEY);
|
return encode(key.getEncoded());
|
}
|
|
/**
|
* 生成密钥对(公钥和私钥)
|
*
|
* @return
|
* @throws Exception
|
*/
|
public static Map<String, Object> genKeyPair() throws Exception {
|
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
|
keyPairGen.initialize(2048);
|
KeyPair keyPair = keyPairGen.generateKeyPair();
|
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
|
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
|
Map<String, Object> keyMap = new HashMap<>(2);
|
keyMap.put(PUBLIC_KEY, publicKey);
|
keyMap.put(PRIVATE_KEY, privateKey);
|
return keyMap;
|
}
|
|
/**
|
* 按 key 进行正序排列，之间以&相连
|
* <功能描述>
|
*
|
* @param params
|
* @return
|
*/
|
public static String getSortParams(Map<String, Object> params) {
|
Map<String, Object> map = new TreeMap<>(Comparator.naturalOrder());
|
map.putAll(params);
|
StringBuffer stringBuffer = new StringBuffer();
|
map.forEach((k, v) -> stringBuffer.append(k).append("=").append(v).append("&"));
|
String str = stringBuffer.toString();
|
if (str.length() > 0) {
|
str = str.substring(0, str.length() - 1);
|
}
|
return str;
|
}
|
|
public static String getSortParams(String data) {
|
return jsonObjConverSortStr(data);
|
}
|
|
/**
|
* BASE64 字符串转二进制数据
|
*
|
* @param base64
|
* @return
|
* @throws Exception
|
*/
|
private static byte[] decode(String base64) throws Exception {
|
return new BASE64Decoder().decodeBuffer(base64);
|
}
|
|
/**
|
* 二进制数据转 BASE64 字符串
|
*
|
* @param bytes
|
* @return
|
* @throws Exception
|
*/
|
private static String encode(byte[] bytes) {
|
return new BASE64Encoder().encode(bytes);
|
}
|
|
/**
|
* 图片转为Base64字符串
|
*
|
* @param url
|
* @return
|
*/
|
public static String pictureToBase64(String url) {
|
String encode = null;
|
try {
|
HttpURLConnection httpUrl = (HttpURLConnection) new URL(url).openConnection();
|
httpUrl.connect();
|
encode = encode(IOUtils.toByteArray(httpUrl.getInputStream()));
|
httpUrl.disconnect();
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return encode;
|
}
|
|
/**
|
* 加签
|
*
|
* @param data 参数
|
* @return
|
* @throws Exception
|
*/
|
public String buildRequest(String data) throws Exception {
|
// 时间戳
|
String timestamp = DateTimeFormatter.ofPattern("yyyyMMddHHmmss").format(LocalDateTime.now());
|
// 构建签名
|
JSONObject root = new JSONObject();
|
root.put("data", data);
|
root.put("timestamp", timestamp);
|
root.put("productNo", productNo);
|
// 排序并拼接成字符串
|
String paramsStr = getSortParams(root);
|
String sign = HySignUtil.sign(paramsStr, local_private_key);
|
root.put("sign", sign);
|
return root.toJSONString();
|
}
|
|
|
/**
|
* @param strReq
|
* @return
|
*/
|
public static Map<String, Object> parseHyRequest(Map<String, String> strReq) {
|
String code = strReq.get("code");
|
String msg = strReq.get("msg");
|
String data = strReq.get("data");
|
//构建响应返回参数
|
Map<String, Object> map = new HashMap<>();
|
map.put("code", code);
|
map.put("msg", msg);
|
map.put("data", data);
|
return map;
|
}
|
|
/**
|
* 验签
|
*
|
* @param strReq
|
* @return
|
* @throws Exception
|
*/
|
public Map<String, Object> parseRequest(String strReq) throws Exception {
|
Map<String, Object> map = JSON.parseObject(strReq, Map.class);
|
JSONObject root = new JSONObject();
|
root.put("productNo", map.get("productNo"));
|
root.put("timestamp", map.get("timestamp"));
|
root.put("data", map.get("data"));
|
//排序并拼接成字符串
|
String paramsStr2 = getSortParams(root.toJSONString());
|
// 验签
|
boolean passed = verify(paramsStr2, other_public_key, (String) map.get("sign"));
|
if (!passed) {
|
throw new RuntimeException("验签失败");
|
}
|
return map;
|
}
|
|
|
public static String jsonObjConverSortStr(String jsonText) {
|
StringBuffer returnBuStr = new StringBuffer();
|
jsonObjParseRecur(returnBuStr, jsonText, true);
|
return returnBuStr.toString();
|
}
|
|
private static void jsonObjParseRecur(StringBuffer returnBuStr, String jsonText, boolean isComplexObj) {
|
JSONObject jsonObj = JSONObject.parseObject(jsonText);
|
Iterator<String> keys = jsonObj.keySet().iterator();
|
// 局部 key 集合 并排序
|
Set<String> keySetSort = new HashSet<>();
|
while (keys.hasNext()) {
|
String key = keys.next();
|
keySetSort.add(key);
|
}
|
List<String> sortList = new ArrayList<>(keySetSort);
|
Collections.sort(sortList);
|
// 开始遍历 递归解析
|
for (String key : sortList) {
|
if (returnBuStr.length() == 0 || isComplexObj) {
|
returnBuStr.append(key).append("=");
|
isComplexObj = false;
|
} else {
|
returnBuStr.append("&").append(key).append("=");
|
}
|
StringBuffer sbSubArr = new StringBuffer();
|
if (jsonObj.get(key) instanceof JSONArray) { // 类型 - JSONArray
|
JSONArray jsonArray = jsonObj.getJSONArray(key);
|
returnBuStr.append("[");
|
for (int i = 0; i < jsonArray.size(); i++) {
|
Object obj = jsonArray.get(i);
|
// JSONArray - 依然是数组元素
|
if (obj instanceof JSONArray) {
|
String jsonArrayObjString = obj.toString();
|
if (sbSubArr.length() == 0) {
|
sbSubArr.append(jsonArrayObjString);
|
} else {
|
sbSubArr.append(",").append(jsonArrayObjString);
|
}
|
continue;
|
}
|
// JSONArray - jsonObj 复杂对象
|
if (obj instanceof JSONObject) {
|
JSONObject jsonObjTemp = jsonArray.getJSONObject(i);
|
if (i == 0) {
|
sbSubArr.append("{");
|
jsonObjParseRecur(sbSubArr, jsonObjTemp.toString(), true);
|
sbSubArr.append("}");
|
} else {
|
sbSubArr.append(",{");
|
jsonObjParseRecur(sbSubArr, jsonObjTemp.toString(), true);
|
sbSubArr.append("}");
|
}
|
}
|
// JSONArray - 普通元素
|
if (!(obj instanceof JSONArray) && !(obj instanceof JSONObject)) {
|
if (sbSubArr.length() == 0) {
|
sbSubArr.append(obj.toString());
|
} else {
|
sbSubArr.append(",").append(obj.toString());
|
}
|
}
|
}
|
returnBuStr.append(sbSubArr);
|
returnBuStr.append("]");
|
} else if (jsonObj.get(key) instanceof JSONObject) { // 类型 - JSONObject
|
returnBuStr.append("{");
|
jsonObjParseRecur(returnBuStr, jsonObj.getString(key), true);
|
returnBuStr.append("}");
|
} else { // 以上两种情况都不是的情况下，则为普通元素
|
returnBuStr.append(jsonObj.get(key).toString());
|
}
|
}
|
}
|
|
/**
|
* 方法描述 ： 发送post请求 MediaType=application/json;charset=UTF-8
|
*
|
* @author : sunjb
|
*/
|
public <T> T sendPostJson(String url, Map<String, String> headerParams, Object obj, Class<T> cla, Integer readTimeOut) throws Exception {
|
|
String params = JSONObject.toJSONString(obj);
|
|
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
|
// 4s 连接时间 4s 超时时间
|
requestFactory.setConnectTimeout(8);
|
requestFactory.setReadTimeout(readTimeOut);
|
RestTemplate restTemplate = new RestTemplate(requestFactory);
|
HttpHeaders httpHeaders = new HttpHeaders();
|
// for (Map.Entry<String,String> entry : headerParams.entrySet()) {
|
// httpHeaders.add(entry.getKey(),entry.getValue());
|
// }
|
HttpMethod httpMethod = HttpMethod.POST;
|
// 以表单的方式提交
|
httpHeaders.setContentType(MediaType.APPLICATION_JSON_UTF8);
|
//将请求头部和参数合成一个请求
|
HttpEntity<String> httpEntity = new HttpEntity(params, httpHeaders);
|
|
ResponseEntity responseEntity = null;
|
try {
|
responseEntity = restTemplate.exchange(url, httpMethod, httpEntity, cla);
|
} catch (Exception e) {
|
throw new RuntimeException(e.getMessage());
|
}
|
|
return (T) responseEntity.getBody();
|
}
|
}
|
