package com.nq.utils.pay;
|
|
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
|
import org.bouncycastle.jce.provider.BouncyCastleProvider;
|
import org.bouncycastle.openssl.PEMKeyPair;
|
import org.bouncycastle.openssl.PEMParser;
|
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
|
|
import java.io.StringReader;
|
import java.nio.charset.StandardCharsets;
|
import java.security.KeyFactory;
|
import java.security.PrivateKey;
|
import java.security.PublicKey;
|
import java.security.Security;
|
import java.security.Signature;
|
import java.security.spec.InvalidKeySpecException;
|
import java.security.spec.PKCS8EncodedKeySpec;
|
import java.security.spec.X509EncodedKeySpec;
|
import java.util.Base64;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
/**
|
* Pay v2 网关数字签名（与官方文档一致）。
|
* <p>
|
* <b>数据拼接 stringA：</b>集合 M 内参数按参数名 ASCII 字典序排序；格式 {@code key1=value1&key2=value2}；
|
* 值为空不参与；不做 URL Encode；{@code sign} 不参与拼接。
|
* <p>
|
* <b>数据签名：</b>对 stringA 使用<b>商户 PKCS8 私钥</b>做 {@code SHA256withRSA}，再 Base64 得到 {@code sign}。
|
* <p>
|
* <b>数据验签：</b>用<b>平台公钥</b>校验。若报文含 {@code data} 对象，则对 {@code data} 内除 {@code sign} 外的字段拼 stringA 再验签（一般为接口响应）；
|
* 否则对顶层除 {@code sign} 外的字段验签（一般为异步通知）。
|
* <p>
|
* 密钥：2048 位、PKCS8 生成可参考 https://uutool.cn/rsa-generate/ ；商户公钥发给客服录入；私钥配置在 {@link com.nq.common.PayV2GatewayKeys#MERCHANT_PRIVATE_KEY_PEM}。
|
*/
|
public final class PayV2RsaSignUtil {
|
|
private static final String RSA = "RSA";
|
private static final String SIGN_ALG = "SHA256withRSA";
|
|
static {
|
if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
|
Security.addProvider(new BouncyCastleProvider());
|
}
|
}
|
|
private PayV2RsaSignUtil() {
|
}
|
|
public static String buildStringA(Map<String, String> params) {
|
Map<String, String> sorted = new TreeMap<>();
|
for (Map.Entry<String, String> e : params.entrySet()) {
|
String k = e.getKey();
|
if (k == null || "sign".equalsIgnoreCase(k)) {
|
continue;
|
}
|
String v = e.getValue();
|
if (v == null || v.isEmpty()) {
|
continue;
|
}
|
sorted.put(k, v);
|
}
|
StringBuilder sb = new StringBuilder();
|
for (Map.Entry<String, String> e : sorted.entrySet()) {
|
sb.append(e.getKey()).append("=").append(e.getValue()).append("&");
|
}
|
if (sb.length() > 0) {
|
sb.setLength(sb.length() - 1);
|
}
|
return sb.toString();
|
}
|
|
public static String sign(String stringA, String merchantPrivateKeyPemOrBase64) throws Exception {
|
PrivateKey privateKey = parsePrivateKey(merchantPrivateKeyPemOrBase64);
|
Signature signature = Signature.getInstance(SIGN_ALG);
|
signature.initSign(privateKey);
|
signature.update(stringA.getBytes(StandardCharsets.UTF_8));
|
return Base64.getEncoder().encodeToString(signature.sign());
|
}
|
|
public static String sign(Map<String, String> params, String merchantPrivateKeyPemOrBase64) throws Exception {
|
return sign(buildStringA(params), merchantPrivateKeyPemOrBase64);
|
}
|
|
public static boolean verify(String stringA, String signBase64, String platformPublicKeyPemOrBase64) {
|
if (signBase64 == null || signBase64.isEmpty()) {
|
return false;
|
}
|
try {
|
PublicKey publicKey = parsePublicKey(platformPublicKeyPemOrBase64);
|
Signature signature = Signature.getInstance(SIGN_ALG);
|
signature.initVerify(publicKey);
|
signature.update(stringA.getBytes(StandardCharsets.UTF_8));
|
byte[] sig = Base64.getDecoder().decode(signBase64.trim().replace("\n", "").replace("\r", ""));
|
return signature.verify(sig);
|
} catch (Exception e) {
|
return false;
|
}
|
}
|
|
public static boolean verify(Map<String, String> params, String signBase64, String platformPublicKeyPemOrBase64) {
|
return verify(buildStringA(params), signBase64, platformPublicKeyPemOrBase64);
|
}
|
|
/**
|
* 解析商户 RSA 私钥：支持 PKCS#8 PEM、PKCS#1 PEM（RSA PRIVATE KEY）、或裸 PKCS#8 Base64。
|
*/
|
public static PrivateKey parsePrivateKey(String pemOrBase64) throws Exception {
|
String s = pemOrBase64 == null ? "" : pemOrBase64.trim();
|
if (s.isEmpty() || s.contains("REPLACE_WITH")) {
|
throw new IllegalArgumentException(
|
"PayV2GatewayKeys.MERCHANT_PRIVATE_KEY_PEM 未配置有效私钥：请粘贴完整 PEM（推荐 PKCS#8：-----BEGIN PRIVATE KEY-----），勿填公钥或占位符。");
|
}
|
if (looksLikeRsaPublicKeySpkiBase64(s)) {
|
throw new IllegalArgumentException(
|
"MERCHANT_PRIVATE_KEY_PEM 内容疑似「公钥」（X.509 SPKI）。签名必须使用「私钥」；公钥应只填在 MERCHANT_PUBLIC_KEY 并发给支付平台。");
|
}
|
if (s.contains("BEGIN")) {
|
try (PEMParser pemParser = new PEMParser(new StringReader(s))) {
|
Object obj = pemParser.readObject();
|
JcaPEMKeyConverter converter = new JcaPEMKeyConverter().setProvider(BouncyCastleProvider.PROVIDER_NAME);
|
if (obj instanceof PEMKeyPair) {
|
return converter.getKeyPair((PEMKeyPair) obj).getPrivate();
|
}
|
if (obj instanceof PrivateKeyInfo) {
|
return converter.getPrivateKey((PrivateKeyInfo) obj);
|
}
|
}
|
throw new IllegalArgumentException(
|
"PEM 中未解析出 RSA 私钥。请确认含 -----BEGIN PRIVATE KEY----- 或 -----BEGIN RSA PRIVATE KEY----- 完整块。");
|
}
|
byte[] keyBytes = Base64.getDecoder().decode(s.replaceAll("\\s+", ""));
|
try {
|
return KeyFactory.getInstance(RSA).generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
|
} catch (InvalidKeySpecException e) {
|
throw new IllegalArgumentException(
|
"裸 Base64 不是 PKCS#8 私钥 DER。请粘贴完整 PEM，或用 openssl：openssl pkcs8 -topk8 -nocrypt -in rsa.key -out pkcs8.pem", e);
|
}
|
}
|
|
/**
|
* 无 PEM 头时，常见 2048 位 RSA 公钥 SPKI 的 Base64 固定前缀（与 PKCS#8 私钥不同）。
|
*/
|
private static boolean looksLikeRsaPublicKeySpkiBase64(String s) {
|
if (s.contains("BEGIN")) {
|
return false;
|
}
|
String compact = s.replaceAll("\\s+", "");
|
return compact.startsWith("MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA");
|
}
|
|
public static PublicKey parsePublicKey(String pemOrBase64) throws Exception {
|
String s = pemOrBase64.trim();
|
byte[] keyBytes;
|
if (s.contains("BEGIN PUBLIC KEY")) {
|
keyBytes = Base64.getDecoder().decode(extractPemBody(s, "-----BEGIN PUBLIC KEY-----", "-----END PUBLIC KEY-----"));
|
} else {
|
keyBytes = Base64.getDecoder().decode(s.replaceAll("\\s+", ""));
|
}
|
return KeyFactory.getInstance(RSA).generatePublic(new X509EncodedKeySpec(keyBytes));
|
}
|
|
private static String extractPemBody(String pem, String begin, String end) {
|
int a = pem.indexOf(begin);
|
if (a < 0) {
|
return pem.replaceAll("\\s+", "");
|
}
|
a += begin.length();
|
int b = pem.indexOf(end, a);
|
if (b < 0) {
|
return pem.substring(a).replaceAll("\\s+", "");
|
}
|
return pem.substring(a, b).replaceAll("\\s+", "");
|
}
|
}
|
