提交基础代码

puzhibing

2023-05-22 8d5196a9663570735148c023367672cc1d86615c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package com.agentdriving.driver.modular.system.util.MallBook.util;
 
 
import com.agentdriving.driver.modular.system.util.MallBook.config.ChannelConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
 
/**
 * @author RSA签名验签类
 */
public class RSASignature {
 
    public static Logger logger = LoggerFactory.getLogger(RSASignature.class);
 
    /**
     * 签名算法
     */
    public static final String SIGN_ALGORITHMS = "SHA1WithRSA";
 
 
    /**
     * 商户平台私钥签名
     *
     * @param content
     * @return
     */
    public static String sign(String content) {
        try {
            String privateKey = ChannelConfig.merchantPrivateKey;
            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decode(privateKey));
            KeyFactory keyf = KeyFactory.getInstance("RSA");
            PrivateKey priKey = keyf.generatePrivate(priPKCS8);
            java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
            signature.initSign(priKey);
            signature.update(content.getBytes());
            byte[] signed = signature.sign();
            return Base64.encode(signed);
        } catch (Exception e) {
            logger.error("签名失败{}", e);
        }
        return null;
    }
 
 
    /**
     * 读取证书
     *
     * @param filePath 证书文件路径
     */
    public static String loadKey(String filePath) throws Exception {
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String readLine;
            StringBuilder sb = new StringBuilder();
            while ((readLine = br.readLine()) != null) {
                sb.append(readLine);
            }
            return sb.toString();
        } catch (IOException e) {
            throw new Exception("私钥数据读取错误");
        } catch (NullPointerException e) {
            throw new Exception("私钥输入流为空");
        }
    }
 
 
    /**
     * mallbook公钥验签
     *
     * @param content 待签名数据
     * @param sign    签名值
     * @return false 验签失败 true 成功
     */
    public static boolean validate(String content, String sign) {
        boolean verify = false;
        try {
            String publicKey = ChannelConfig.mallBookPublicKey;
            verify = RSASignature.doCheck(content, sign, publicKey, "utf-8");
        } catch (Exception e) {
            logger.error("验签失败：{}", e);
        }
        return verify;
    }
 
 
    /**
     * RSA验签
     *
     * @param content   待签名数据
     * @param sign      签名值
     * @param publicKey 分配给开发商公钥
     * @param encode    字符集编码
     * @return 布尔值
     */
    public static boolean doCheck(String content, String sign, String publicKey, String encode) {
        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            byte[] encodedKey = Base64.decode(publicKey);
            PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
            java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
            signature.initVerify(pubKey);
            signature.update(content.getBytes(encode));
            return signature.verify(Base64.decode(sign));
        } catch (Exception e) {
            logger.error("验签失败{}", e);
        }
        return false;
    }
 
}