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. what？iView的DropDown没有element的split-button？提issure？等不及了，自己实现一个

    开始正文之前,有必要先说自己实现这个组件的必要性描述. 话说大家做表格时,增删查改按钮都是放在哪里的?最简单的方式应该是这样: 是不是感觉奇丑无比啊,于是改成了这样: 但是这种操作按钮一多后就没位置放 ...

  2. wm_concat函数的排序问题

    wm_concat在行转列的时候非常有用,但在行转列的过程中的排序问题常常难以控制. 可见下面例子: 准备测试表: drop table t; create table t (n number,m n ...

  3. Mysql 导入CSV文件，中文内容乱码问题

    项目中用到含有中文字段的数据CSV文件,导入Mysql数据中发现中文内容乱码. 分析原因:因为数据库字符编码问题引起. [1]创建utf-8字符集数据库 CREATE DATABASE db_name ...

  4. JQuery 中$("input:eq(0)") eq 的意思

    :eq(index)匹配一个给定索引值的元素 ----------------------------------------------------- Matches a single elemen ...

  5. FineReport中日期时间函数使用总结

    说明:凡函数中以日期作为参数因子的,其中日期的形式都必须是yy/mm/dd.而且必须用英文环境下双引号(" ")引用. DATE DATE(year,month,day):返回一个 ...

  6. C++ this指针的详解

    C++中this指针的用法详解   转自:http://blog.chinaunix.net/uid-21411227-id-1826942.html 1. this指针的用处: 一个对象的this指 ...

  7. [Offer收割] 编程练习赛63

    题目1 : 命名 时间限制:5000ms 单点时限:1000ms 内存限制:256MB 描述 有两个公司想要合并,第一个公司的名字是一个字符串S,第二个公司的名字是一个字符串T. 合并后的新公司是这样 ...

  8. Solr中在使用过程中遇到的"与"和"或"的问题

    在进行全文检索的过程中,如果使用三星和手机,两个一块进行搜索的时候,关于三星的会被搜索出来,关于手机的信息也会被搜索出来,然后,需要将一些配置文件进行配置, <!-- DEPRECATED: T ...

  9. 【题解】Luogu P2081 [NOI2012]迷失游乐园

    原题传送门 这是当时冬令营课上讲的题,咕咕咕到了现在 如果这题没有环套树的话,就很套路了 需要两个数组up[i]和down[i],down[i]表示从i点第一步向下走的期望距离,up[i]表示从i点第 ...

  10. Vue中使用Cropper.js裁剪图片

    Cropper.js是一款很好用的图片裁剪工具,可以对图片的尺寸.宽高比进行裁剪,满足诸如裁剪头像上传.商品图片编辑之类的需求. github: https://github.com/fengyuan ...