RSA加密解密类：

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
package com.ihep;
import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.FileReader; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.security.InvalidKeyException; 
import java.security.KeyFactory; 
import java.security.KeyPair; 
import java.security.KeyPairGenerator; 
import java.security.NoSuchAlgorithmException; 
import java.security.SecureRandom; 
   
import java.security.interfaces.RSAPrivateKey; 
import java.security.interfaces.RSAPublicKey; 
import java.security.spec.InvalidKeySpecException; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec; 
   
import javax.crypto.BadPaddingException; 
import javax.crypto.Cipher; 
import javax.crypto.IllegalBlockSizeException; 
import javax.crypto.NoSuchPaddingException; 
   
public class RSAEncrypt { 
    /**
     * 字节数据转字符串专用集合
     */ 
    private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6', 
            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; 
   
    /**
     * 随机生成密钥对
     */ 
    public static void genKeyPair(String filePath) { 
        // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象 
        KeyPairGenerator keyPairGen = null; 
        try { 
            keyPairGen = KeyPairGenerator.getInstance("RSA"); 
        } catch (NoSuchAlgorithmException e) { 
            // TODO Auto-generated catch block 
            e.printStackTrace(); 
        } 
        // 初始化密钥对生成器，密钥大小为96-1024位 
        keyPairGen.initialize(1024,new SecureRandom()); 
        // 生成一个密钥对，保存在keyPair中 
        KeyPair keyPair = keyPairGen.generateKeyPair(); 
        // 得到私钥 
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); 
        // 得到公钥 
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); 
        try { 
            // 得到公钥字符串 
            String publicKeyString = Base64.encode(publicKey.getEncoded()); 
            // 得到私钥字符串 
            String privateKeyString = Base64.encode(privateKey.getEncoded()); 
            // 将密钥对写入到文件 
            FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore"); 
            FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore"); 
            BufferedWriter pubbw = new BufferedWriter(pubfw); 
            BufferedWriter pribw = new BufferedWriter(prifw); 
            pubbw.write(publicKeyString); 
            pribw.write(privateKeyString); 
            pubbw.flush(); 
            pubbw.close(); 
            pubfw.close(); 
            pribw.flush(); 
            pribw.close(); 
            prifw.close(); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 
   
    /**
     * 从文件中输入流中加载公钥
     * 
     * @param in
     *            公钥输入流
     * @throws Exception
     *             加载公钥时产生的异常
     */ 
    public static String loadPublicKeyByFile(String path) throws Exception { 
        try { 
            BufferedReader br = new BufferedReader(new FileReader(path 
                    + "/publicKey.keystore")); 
            String readLine = null; 
            StringBuilder sb = new StringBuilder(); 
            while ((readLine = br.readLine()) != null) { 
                sb.append(readLine); 
            } 
            br.close(); 
            return sb.toString(); 
        } catch (IOException e) { 
            throw new Exception("公钥数据流读取错误"); 
        } catch (NullPointerException e) { 
            throw new Exception("公钥输入流为空"); 
        } 
    } 
   
    /**
     * 从字符串中加载公钥
     * 
     * @param publicKeyStr
     *            公钥数据字符串
     * @throws Exception
     *             加载公钥时产生的异常
     */ 
    public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr) 
            throws Exception { 
        try { 
            byte[] buffer = Base64.decode(publicKeyStr); 
            KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer); 
            return (RSAPublicKey) keyFactory.generatePublic(keySpec); 
        } catch (NoSuchAlgorithmException e) { 
            throw new Exception("无此算法"); 
        } catch (InvalidKeySpecException e) { 
            throw new Exception("公钥非法"); 
        } catch (NullPointerException e) { 
            throw new Exception("公钥数据为空"); 
        } 
    } 
   
    /**
     * 从文件中加载私钥
     * 
     * @param keyFileName
     *            私钥文件名
     * @return 是否成功
     * @throws Exception
     */ 
    public static String loadPrivateKeyByFile(String path) throws Exception { 
        try { 
            BufferedReader br = new BufferedReader(new FileReader(path 
                    + "/privateKey.keystore")); 
            String readLine = null; 
            StringBuilder sb = new StringBuilder(); 
            while ((readLine = br.readLine()) != null) { 
                sb.append(readLine); 
            } 
            br.close(); 
            return sb.toString(); 
        } catch (IOException e) { 
            throw new Exception("私钥数据读取错误"); 
        } catch (NullPointerException e) { 
            throw new Exception("私钥输入流为空"); 
        } 
    } 
   
    public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr) 
            throws Exception { 
        try { 
            byte[] buffer = Base64.decode(privateKeyStr); 
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer); 
            KeyFactory keyFactory = KeyFactory.getInstance("RSA"); 
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec); 
        } catch (NoSuchAlgorithmException e) { 
            throw new Exception("无此算法"); 
        } catch (InvalidKeySpecException e) { 
            throw new Exception("私钥非法"); 
        } catch (NullPointerException e) { 
            throw new Exception("私钥数据为空"); 
        } 
    } 
   
    /**
     * 公钥加密过程
     * 
     * @param publicKey
     *            公钥
     * @param plainTextData
     *            明文数据
     * @return
     * @throws Exception
     *             加密过程中的异常信息
     */ 
    public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) 
            throws Exception { 
        if (publicKey == null) { 
            throw new Exception("加密公钥为空, 请设置"); 
        } 
        Cipher cipher = null; 
        try { 
            // 使用默认RSA 
            cipher = Cipher.getInstance("RSA"); 
            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider()); 
            cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
            byte[] output = cipher.doFinal(plainTextData); 
            return output; 
        } catch (NoSuchAlgorithmException e) { 
            throw new Exception("无此加密算法"); 
        } catch (NoSuchPaddingException e) { 
            e.printStackTrace(); 
            return null; 
        } catch (InvalidKeyException e) { 
            throw new Exception("加密公钥非法,请检查"); 
        } catch (IllegalBlockSizeException e) { 
            throw new Exception("明文长度非法"); 
        } catch (BadPaddingException e) { 
            throw new Exception("明文数据已损坏"); 
        } 
    } 
   
    /**
     * 私钥加密过程
     * 
     * @param privateKey
     *            私钥
     * @param plainTextData
     *            明文数据
     * @return
     * @throws Exception
     *             加密过程中的异常信息
     */ 
    public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData) 
            throws Exception { 
        if (privateKey == null) { 
            throw new Exception("加密私钥为空, 请设置"); 
        } 
        Cipher cipher = null; 
        try { 
            // 使用默认RSA 
            cipher = Cipher.getInstance("RSA"); 
            cipher.init(Cipher.ENCRYPT_MODE, privateKey); 
            byte[] output = cipher.doFinal(plainTextData); 
            return output; 
        } catch (NoSuchAlgorithmException e) { 
            throw new Exception("无此加密算法"); 
        } catch (NoSuchPaddingException e) { 
            e.printStackTrace(); 
            return null; 
        } catch (InvalidKeyException e) { 
            throw new Exception("加密私钥非法,请检查"); 
        } catch (IllegalBlockSizeException e) { 
            throw new Exception("明文长度非法"); 
        } catch (BadPaddingException e) { 
            throw new Exception("明文数据已损坏"); 
        } 
    } 
   
    /**
     * 私钥解密过程
     * 
     * @param privateKey
     *            私钥
     * @param cipherData
     *            密文数据
     * @return 明文
     * @throws Exception
     *             解密过程中的异常信息
     */ 
    public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) 
            throws Exception { 
        if (privateKey == null) { 
            throw new Exception("解密私钥为空, 请设置"); 
        } 
        Cipher cipher = null; 
        try { 
            // 使用默认RSA 
            cipher = Cipher.getInstance("RSA"); 
            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider()); 
            cipher.init(Cipher.DECRYPT_MODE, privateKey); 
            byte[] output = cipher.doFinal(cipherData); 
            return output; 
        } catch (NoSuchAlgorithmException e) { 
            throw new Exception("无此解密算法"); 
        } catch (NoSuchPaddingException e) { 
            e.printStackTrace(); 
            return null; 
        } catch (InvalidKeyException e) { 
            throw new Exception("解密私钥非法,请检查"); 
        } catch (IllegalBlockSizeException e) { 
            throw new Exception("密文长度非法"); 
        } catch (BadPaddingException e) { 
            throw new Exception("密文数据已损坏"); 
        } 
    } 
   
    /**
     * 公钥解密过程
     * 
     * @param publicKey
     *            公钥
     * @param cipherData
     *            密文数据
     * @return 明文
     * @throws Exception
     *             解密过程中的异常信息
     */ 
    public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData) 
            throws Exception { 
        if (publicKey == null) { 
            throw new Exception("解密公钥为空, 请设置"); 
        } 
        Cipher cipher = null; 
        try { 
            // 使用默认RSA 
            cipher = Cipher.getInstance("RSA"); 
            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider()); 
            cipher.init(Cipher.DECRYPT_MODE, publicKey); 
            byte[] output = cipher.doFinal(cipherData); 
            return output; 
        } catch (NoSuchAlgorithmException e) { 
            throw new Exception("无此解密算法"); 
        } catch (NoSuchPaddingException e) { 
            e.printStackTrace(); 
            return null; 
        } catch (InvalidKeyException e) { 
            throw new Exception("解密公钥非法,请检查"); 
        } catch (IllegalBlockSizeException e) { 
            throw new Exception("密文长度非法"); 
        } catch (BadPaddingException e) { 
            throw new Exception("密文数据已损坏"); 
        } 
    } 
   
    /**
     * 字节数据转十六进制字符串
     * 
     * @param data
     *            输入数据
     * @return 十六进制内容
     */ 
    public static String byteArrayToString(byte[] data) { 
        StringBuilder stringBuilder = new StringBuilder(); 
        for (int i = 0; i < data.length; i++) { 
            // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移 
            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]); 
            // 取出字节的低四位 作为索引得到相应的十六进制标识符 
            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]); 
            if (i < data.length - 1) { 
                stringBuilder.append(' '); 
            } 
        } 
        return stringBuilder.toString(); 
    } 
}

签名及校验类：

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
package com.ihep;
import java.security.KeyFactory; 
import java.security.PrivateKey; 
import java.security.PublicKey; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec; 
   
/**
 * RSA签名验签类
 */ 
public class RSASignature{ 
       
    /**
     * 签名算法
     */ 
    public static final String SIGN_ALGORITHMS = "SHA1WithRSA"; 
   
    /**
    * RSA签名
    * @param content 待签名数据
    * @param privateKey 商户私钥
    * @param encode 字符集编码
    * @return 签名值
    */ 
    public static String sign(String content, String privateKey, String encode) 
    { 
        try  
        { 
            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(encode)); 
   
            byte[] signed = signature.sign(); 
               
            return Base64.encode(signed); 
        } 
        catch (Exception e)  
        { 
            e.printStackTrace(); 
        } 
           
        return null; 
    } 
       
    public static String sign(String content, String privateKey) 
    { 
        try  
        { 
            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)  
        { 
            e.printStackTrace(); 
        } 
        return null; 
    } 
       
    /**
    * 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) ); 
           
            boolean bverify = signature.verify( Base64.decode(sign) ); 
            return bverify; 
               
        }  
        catch (Exception e)  
        { 
            e.printStackTrace(); 
        } 
           
        return false; 
    } 
       
    public static boolean doCheck(String content, String sign, String publicKey) 
    { 
        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() ); 
           
            boolean bverify = signature.verify( Base64.decode(sign) ); 
            return bverify; 
               
        }  
        catch (Exception e)  
        {
            e.printStackTrace(); 
        }
           
        return false; 
    } 
       
}

再来一个Base64的类，当然你也可以用commons-codec-1.9.jar

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
package com.ihep; 
   
public final class Base64 { 
   
    static private final int     BASELENGTH           = 128; 
    static private final int     LOOKUPLENGTH         = 64; 
    static private final int     TWENTYFOURBITGROUP   = 24; 
    static private final int     EIGHTBIT             = 8; 
    static private final int     SIXTEENBIT           = 16; 
    static private final int     FOURBYTE             = 4; 
    static private final int     SIGN                 = -128; 
    static private final char    PAD                  = '='; 
    static private final boolean fDebug               = false; 
    static final private byte[]  base64Alphabet       = new byte[BASELENGTH]; 
    static final private char[]  lookUpBase64Alphabet = new char[LOOKUPLENGTH]; 
   
    static { 
        for (int i = 0; i < BASELENGTH; ++i) { 
            base64Alphabet[i] = -1; 
        } 
        for (int i = 'Z'; i >= 'A'; i--) { 
            base64Alphabet[i] = (byte) (i - 'A'); 
        } 
        for (int i = 'z'; i >= 'a'; i--) { 
            base64Alphabet[i] = (byte) (i - 'a' + 26); 
        } 
   
        for (int i = '9'; i >= '0'; i--) { 
            base64Alphabet[i] = (byte) (i - '0' + 52); 
        } 
   
        base64Alphabet['+'] = 62; 
        base64Alphabet['/'] = 63; 
   
        for (int i = 0; i <= 25; i++) { 
            lookUpBase64Alphabet[i] = (char) ('A' + i); 
        } 
   
        for (int i = 26, j = 0; i <= 51; i++, j++) { 
            lookUpBase64Alphabet[i] = (char) ('a' + j); 
        } 
   
        for (int i = 52, j = 0; i <= 61; i++, j++) { 
            lookUpBase64Alphabet[i] = (char) ('0' + j); 
        } 
        lookUpBase64Alphabet[62] = (char) '+'; 
        lookUpBase64Alphabet[63] = (char) '/'; 
   
    } 
   
    private static boolean isWhiteSpace(char octect) { 
        return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9); 
    } 
   
    private static boolean isPad(char octect) { 
        return (octect == PAD); 
    } 
   
    private static boolean isData(char octect) { 
        return (octect < BASELENGTH && base64Alphabet[octect] != -1); 
    } 
   
    /**
     * Encodes hex octects into Base64
     *
     * @param binaryData Array containing binaryData
     * @return Encoded Base64 array
     */ 
    public static String encode(byte[] binaryData) { 
   
        if (binaryData == null) { 
            return null; 
        } 
   
        int lengthDataBits = binaryData.length * EIGHTBIT; 
        if (lengthDataBits == 0) { 
            return ""; 
        } 
   
        int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP; 
        int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP; 
        int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets; 
        char encodedData[] = null; 
   
        encodedData = new char[numberQuartet * 4]; 
   
        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0; 
   
        int encodedIndex = 0; 
        int dataIndex = 0; 
        if (fDebug) { 
            System.out.println("number of triplets = " + numberTriplets); 
        } 
   
        for (int i = 0; i < numberTriplets; i++) { 
            b1 = binaryData[dataIndex++]; 
            b2 = binaryData[dataIndex++]; 
            b3 = binaryData[dataIndex++]; 
   
            if (fDebug) { 
                System.out.println("b1= " + b1 + ", b2= " + b2 + ", b3= " + b3); 
            } 
   
            l = (byte) (b2 & 0x0f); 
            k = (byte) (b1 & 0x03); 
   
            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); 
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); 
            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc); 
   
            if (fDebug) { 
                System.out.println("val2 = " + val2); 
                System.out.println("k4   = " + (k << 4)); 
                System.out.println("vak  = " + (val2 | (k << 4))); 
            } 
   
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)]; 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3]; 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f]; 
        } 
   
        // form integral number of 6-bit groups 
        if (fewerThan24bits == EIGHTBIT) { 
            b1 = binaryData[dataIndex]; 
            k = (byte) (b1 & 0x03); 
            if (fDebug) { 
                System.out.println("b1=" + b1); 
                System.out.println("b1<<2 = " + (b1 >> 2)); 
            } 
            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4]; 
            encodedData[encodedIndex++] = PAD; 
            encodedData[encodedIndex++] = PAD; 
        } else if (fewerThan24bits == SIXTEENBIT) { 
            b1 = binaryData[dataIndex]; 
            b2 = binaryData[dataIndex + 1]; 
            l = (byte) (b2 & 0x0f); 
            k = (byte) (b1 & 0x03); 
   
            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); 
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); 
   
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)]; 
            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2]; 
            encodedData[encodedIndex++] = PAD; 
        } 
   
        return new String(encodedData); 
    } 
   
    /**
     * Decodes Base64 data into octects
     *
     * @param encoded string containing Base64 data
     * @return Array containind decoded data.
     */ 
    public static byte[] decode(String encoded) { 
   
        if (encoded == null) { 
            return null; 
        } 
   
        char[] base64Data = encoded.toCharArray(); 
        // remove white spaces 
        int len = removeWhiteSpace(base64Data); 
   
        if (len % FOURBYTE != 0) { 
            return null;//should be divisible by four 
        } 
   
        int numberQuadruple = (len / FOURBYTE); 
   
        if (numberQuadruple == 0) { 
            return new byte[0]; 
        } 
   
        byte decodedData[] = null; 
        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0; 
        char d1 = 0, d2 = 0, d3 = 0, d4 = 0; 
   
        int i = 0; 
        int encodedIndex = 0; 
        int dataIndex = 0; 
        decodedData = new byte[(numberQuadruple) * 3]; 
   
        for (; i < numberQuadruple - 1; i++) { 
   
            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])) 
                || !isData((d3 = base64Data[dataIndex++])) 
                || !isData((d4 = base64Data[dataIndex++]))) { 
                return null; 
            }//if found "no data" just return null 
   
            b1 = base64Alphabet[d1]; 
            b2 = base64Alphabet[d2]; 
            b3 = base64Alphabet[d3]; 
            b4 = base64Alphabet[d4]; 
   
            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); 
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); 
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); 
        } 
   
        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) { 
            return null;//if found "no data" just return null 
        } 
   
        b1 = base64Alphabet[d1]; 
        b2 = base64Alphabet[d2]; 
   
        d3 = base64Data[dataIndex++]; 
        d4 = base64Data[dataIndex++]; 
        if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters 
            if (isPad(d3) && isPad(d4)) { 
                if ((b2 & 0xf) != 0)//last 4 bits should be zero 
                { 
                    return null; 
                } 
                byte[] tmp = new byte[i * 3 + 1]; 
                System.arraycopy(decodedData, 0, tmp, 0, i * 3); 
                tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); 
                return tmp; 
            } else if (!isPad(d3) && isPad(d4)) { 
                b3 = base64Alphabet[d3]; 
                if ((b3 & 0x3) != 0)//last 2 bits should be zero 
                { 
                    return null; 
                } 
                byte[] tmp = new byte[i * 3 + 2]; 
                System.arraycopy(decodedData, 0, tmp, 0, i * 3); 
                tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); 
                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); 
                return tmp; 
            } else { 
                return null; 
            } 
        } else { //No PAD e.g 3cQl 
            b3 = base64Alphabet[d3]; 
            b4 = base64Alphabet[d4]; 
            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); 
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); 
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); 
   
        } 
   
        return decodedData; 
    } 
   
    /**
     * remove WhiteSpace from MIME containing encoded Base64 data.
     *
     * @param data  the byte array of base64 data (with WS)
     * @return      the new length
     */ 
    private static int removeWhiteSpace(char[] data) { 
        if (data == null) { 
            return 0; 
        } 
   
        // count characters that's not whitespace 
        int newSize = 0; 
        int len = data.length; 
        for (int i = 0; i < len; i++) { 
            if (!isWhiteSpace(data[i])) { 
                data[newSize++] = data[i]; 
            } 
        } 
        return newSize; 
    } 
}

最后是一个MainTest：

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
package com.ihep; 
   
public class MainTest { 
   
    public static void main(String[] args) throws Exception { 
        String filepath="E:/tmp/"; 
   
        //生成公钥和私钥文件
        RSAEncrypt.genKeyPair(filepath);
           
        System.out.println("--------------公钥加密私钥解密过程-------------------"); 
        String plainText="ihep_公钥加密私钥解密"; 
        //公钥加密过程 
        byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),plainText.getBytes()); 
        String cipher=Base64.encode(cipherData); 
        //私钥解密过程 
        byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decode(cipher)); 
        String restr=new String(res); 
        System.out.println("原文："+plainText); 
        System.out.println("加密："+cipher); 
        System.out.println("解密："+restr); 
        System.out.println(); 
           
        System.out.println("--------------私钥加密公钥解密过程-------------------"); 
        plainText="ihep_私钥加密公钥解密"; 
        //私钥加密过程 
        cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),plainText.getBytes()); 
        cipher=Base64.encode(cipherData); 
        //公钥解密过程 
        res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), Base64.decode(cipher)); 
        restr=new String(res); 
        System.out.println("原文："+plainText); 
        System.out.println("加密："+cipher); 
        System.out.println("解密："+restr); 
        System.out.println(); 
           
        System.out.println("---------------私钥签名过程------------------"); 
        String content="ihep_这是用于签名的原始数据"; 
        String signstr=RSASignature.sign(content,RSAEncrypt.loadPrivateKeyByFile(filepath)); 
        System.out.println("签名原串："+content); 
        System.out.println("签名串："+signstr); 
        System.out.println(); 
           
        System.out.println("---------------公钥校验签名------------------"); 
        System.out.println("签名原串："+content); 
        System.out.println("签名串："+signstr); 
           
        System.out.println("验签结果："+RSASignature.doCheck(content, signstr, RSAEncrypt.loadPublicKeyByFile(filepath))); 
        System.out.println(); 
           
    } 
}

三、运行效果

在 E盘 建立一个tmp目录。然后运行 MainTest类（该类有main方法）。

1、自动生成公钥和私钥文件：

2、eclipse控制台输出信息如下：

Java使用RSA加密解密签名及校验的更多相关文章

  1. iOS使用Security.framework进行RSA 加密解密签名和验证签名

    iOS 上 Security.framework为我们提供了安全方面相关的api: Security框架提供的RSA在iOS上使用的一些小结 支持的RSA keySize 大小有:512,768,10 ...

  2. C# 与JAVA 的RSA 加密解密交互，互通，C#使用BouncyCastle来实现私钥加密，公钥解密的方法

    因为C#的RSA加密解密只有公钥加密,私钥解密,没有私钥加密,公钥解密.在网上查了很久也没有很好的实现.BouncyCastle的文档少之又少.很多人可能会说,C#也是可以的,通过Biginteger ...

  3. C#的RSA加密解密签名，就为了支持PEM PKCS#8格式密钥对的导入导出

    差点造了一整个轮子 .Net Framework 4.5 里面的RSA功能,并未提供简单对PEM密钥格式的支持(.Net Core有咩?),差点(还远着)造了一整个轮子,就为了支持PEM PKCS#8 ...

  4. Java使用RSA加密解密及签名校验

    该工具类中用到了BASE64,需要借助第三方类库:javabase64-1.3.1.jar注意:RSA加密明文最大长度117字节,解密要求密文最大长度为128字节,所以在加密和解密的过程中需要分块进行 ...

  5. Java RSA 加密 解密 签名 验签

    原文:http://gaofulai1988.iteye.com/blog/2262802 import java.io.FileInputStream; import java.io.FileOut ...

  6. JAVA实现RSA加密解密 非对称算法

    首先RSA是一个非对称的加密算法.所以在使用该算法加密解密之前,必须先行生成密钥对.包含公钥和私钥 JDK中提供了生成密钥对的类KeyPairGenerator,实比例如以下: public stat ...

  7. iOS and JAVA 的 RSA 加密解密 (转载整理 )

    参考原文地址:http://www.cnblogs.com/makemelike/articles/3802518.html (至于RSA的基本原理,大家可以看 阮一峰的网络日志 的 RSA算法原理( ...

  8. Cryptopp iOS 使用 RSA加密解密和签名验证签名

    Cryptopp 是一个c++写的功能完善的密码学工具,类似于openssl 官网:https://www.cryptopp.com 以下主要演示Cryptopp 在iOS上的RSA加密解密签名与验证 ...

  9. RSA加密解密及数字签名Java实现--转

    RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest).阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的.当时他们三人都在麻省理工学院 ...

随机推荐

  1. Goland开发工具安装教程

    开发工具: 文本类的编辑器:记事本,notepad,sublime text,atom... 通过命令执行程序 IED:集成开发环境(integrated development environmen ...

  2. Java8-对map排序

    1.Java8对map按key排序 /** * @author : fengkun * @date : 19-3-10 * 内容 : Java8对map按key排序 */ public class S ...

  3. Vue 组件&组件之间的通信 父子组件的通信

    在Vue的组件内也可以定义组件,这种关系成为父子组件的关系: 如果在一个Vue实例中定义了component-a,然后在component-a中定义了component-b,那他们的关系就是: Vue ...

  4. 破解360doc个人图书馆网站的右键、复制方法

    chrome浏览器如下做法: 右上角菜单按钮→设置→显示高级设置→隐私设置下的 内容设置按钮→javascript下的管理例外情况→添加 [*.]360doc.com 设置为禁止 →完成

  5. JsTree 最详细教程及完整实例

    JsTree是一个jquery的插件,它提交一个非常友好并且强大的交互性的树,并且是完全免费或开源的(MIT 许可).Jstree技持Html 或 json格式的的数据, 或者是ajax方式的动态请求 ...

  6. dt转换List CovertListHelper

    public class CovertListHelper { //传递过来的类型必须与数据库类型保持一致问题 public List<T> convertToList<T>( ...

  7. Mybatis Generator代码自动生成（实体类、dao层、映射文件）

    写了一段时间增删改查有点厌烦,自己找了下网上的例子鼓捣了下自动生成. 首先得有一个配置文件: generatorConfig.xml <?xml version="1.0" ...

  8. 让selenium中的Cromerderive不加载图片设置

    把配置参数(chrom_opt)设置好后将其添加到 browser = webdriver.Chrome(executable_path="chromedriver.exe的路径" ...

  9. 单体 VS 微服务

    看图说话 群里发来一张图, 形象TM又生动: 异同之处 借此对比说说单体和微服务的异同之处: 一大坨的时候, 难泄, 具体表现为, 牵一发而动全身, 时而久之, 便秘/肠道不适/影响代谢/肤色变差/身 ...

  10. oracle数据库查看和解除死锁

    查看死锁: select sess.sid, sess.serial#, lo.oracle_username, lo.os_user_name, ao.object_name, lo.locked_ ...