1

13693261870

2024-11-13 024e90554d19c2342f27a26f91bbea378f84da82

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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package com.moon.server.helper;
 
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.io.ClassPathResource;
 
import javax.crypto.Cipher;
import java.io.*;
import java.nio.charset.StandardCharsets;
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.util.HashMap;
import java.util.Map;
 
@SuppressWarnings("ALL")
public class RsaHelper {
    private static String privateKey;
 
    private static String publicKey;
 
    private static final String KEY_ALGORITHM = "RSA";
 
    private static final int DEFAULT_RSA_KEY_SIZE = 1024;
 
    private final static Log log = LogFactory.getLog(RsaHelper.class);
 
    public static void generate() {
        Map<String, String> result = generateRsaKey(DEFAULT_RSA_KEY_SIZE);
        System.out.println("公钥为：" + result.get("publicKey"));
        System.out.println("私钥为：" + result.get("privateKey"));
    }
 
    public static String getPrivateKey() throws IOException {
        if (privateKey == null) {
            InputStream inPrivate = new ClassPathResource("config" + File.separator + "rsa_private_key.txt").getInputStream();
            privateKey = inputStream2String(inPrivate);
            inPrivate.close();
        }
 
        return privateKey;
    }
 
    public static String getPublicKey() throws IOException {
        if (publicKey == null) {
            InputStream inPrivate = new ClassPathResource("config" + File.separator + "rsa_public_key.txt").getInputStream();
            publicKey = inputStream2String(inPrivate);
            inPrivate.close();
        }
 
        return publicKey;
    }
 
    public static String readFile(String fileName) throws IOException {
        File file = new File(fileName);
        BufferedReader br = new BufferedReader(new FileReader(file));
 
        StringBuilder result = new StringBuilder();
 
        String line = null;
        while ((line = br.readLine()) != null) {
            result.append(System.lineSeparator() + line);
        }
        br.close();
 
        return result.toString();
    }
 
    private static String inputStream2String(InputStream is) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
        int i = -1;
        while ((i = is.read()) != -1) {
            baos.write(i);
        }
 
        String str = baos.toString();
        baos.close();
 
        return str;
    }
 
    public static Map<String, String> generateRsaKey(int keySize) {
        Map<String, String> result = new HashMap<>(2);
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
 
            keyPairGen.initialize(keySize, new SecureRandom());
 
            KeyPair keyPair = keyPairGen.generateKeyPair();
 
            String pub = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
            result.put("publicKey", pub);
 
            String pri = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));
            result.put("privateKey", pri);
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }
 
        return result;
    }
 
    public static String decrypt(String str) throws Exception {
        byte[] inputByte = Base64.decodeBase64(str.getBytes(StandardCharsets.UTF_8));
 
        byte[] decoded = Base64.decodeBase64(getPrivateKey());
        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
 
        // RSA/ECB/NoPadding
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, priKey);
 
        String outStr = new String(cipher.doFinal(inputByte));
 
        return outStr;
    }
 
    public static String encrypt(String str) throws Exception {
        byte[] decoded = Base64.decodeBase64(getPublicKey());
 
        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
 
        // RSA/ECB/NoPadding
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
 
        String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes(StandardCharsets.UTF_8)));
 
        return outStr;
    }
}