Android C、C++與java端RSA互通

版權聲明：本文爲博主原創文章，遵循 CC 4.0 BY-SA 版權協議，轉載請附上原文出處連接和本聲明。

本文連接： https://blog.csdn.net/zxdscn/article/details/78098882

直接上代碼：

    
    
    
    

     
     
     
     
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
    
    
    
    
public class RSAUtils {

    //加密算法RSA
    public static final String KEY_ALGORITHM = "RSA";
    //獲取公鑰的key
    private static final String PUBLIC_KEY = "RSAPublicKey";
    //獲取私鑰的key
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    //RSA最大加密明文大小
    private static final int MAX_ENCRYPT_BLOCK = 117;
    //RSA最大解密密文大小
    private static final int MAX_DECRYPT_BLOCK = 128;

    private static final String RSA = "RSA/ECB/NoPadding";

    //"RSA/None/PKCS1Padding"; "RSA/ECB/PKCS1Padding"; "RSA"; "RSA/None/NoPadding";

    /** * 隨機生成RSA密鑰對 * * @return */
    public static Map<String, Object> genKeyPair() {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            keyPairGen.initialize(1024);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            Map<String, Object> keyMap = new HashMap<String, Object>(2);
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;

    }

    /** * 獲取私鑰 */
    public static String getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return Base64Util.encode(key.getEncoded());
    }

    /** * 獲取公鑰 */
    public static String getPublicKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return Base64Util.encode(key.getEncoded());
    }

    /** * 用公鑰加密 <br> * 每次加密的字節數，不能超過密鑰的長度值減去11 * * @param data 需加密數據的byte數據 * @param publicKey 公鑰 * @return 加密後的byte型數據 */
    public static byte[] encryptData(byte[] data, PublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            // 編碼前設定編碼方式及密鑰
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            // 傳入編碼數據並返回編碼結果
            return cipher.doFinal(data);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /** * 用私鑰解密 * * @param encryptedData 通過encryptedData()加密返回的byte數據 * @param privateKey 私鑰 * @return */
    public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(encryptedData);
        } catch (Exception e) {
            return null;
        }
    }

    /** * 公鑰加密 * * @param data 明文 * @param publicKey 公鑰字節 * @return * @throws Exception */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) {
        try {
            PublicKey publicK = getPublicKey(publicKey);
            // 對數據加密
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.ENCRYPT_MODE, publicK);
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 對數據分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet >= MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return encryptedData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) {
        try {
            PrivateKey privateK = getPrivateKey(privateKey);
            Cipher cipher = Cipher.getInstance(RSA);
            cipher.init(Cipher.DECRYPT_MODE, privateK);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 對數據分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return decryptedData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /** * 經過公鑰byte[](publicKey.getEncoded())將公鑰還原，適用於RSA算法 * 從字符串中加載公鑰 * * @param publicKey * @return * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException */
    public static PublicKey getPublicKey(String publicKey) {
        try {
            byte[] keyBytes = Base64Util.decode(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey pubKey = keyFactory.generatePublic(keySpec);
            return pubKey;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /** * 經過私鑰byte[]將私鑰還原，適用於RSA算法 * 從字符串中加載私鑰<br> * * @param privateKey * @return * @throws NoSuchAlgorithmException * @throws InvalidKeySpecException */
    public static PrivateKey getPrivateKey(String privateKey) {
        try {
            byte[] keyBytes = Base64Util.decode(privateKey);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey priKey = keyFactory.generatePrivate(keySpec);
            return priKey;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /** * 使用N、e值還原公鑰 * * @param modulus * @param publicExponent * @return */
    public static PublicKey getPublicKey(String modulus, String publicExponent) {
        try {
            BigInteger bigIntModulus = new BigInteger(modulus);
            BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            return publicKey;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    public static PublicKey getPublicKey(byte[] modulus, String publicExponent) {
        try {
            BigInteger bigIntModulus = new BigInteger(1, modulus);
            BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            return publicKey;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /** * 使用N、d值還原私鑰 * * @param modulus * @param privateExponent * @return */
    public static PrivateKey getPrivateKey(String modulus, String privateExponent) {
        try {

            BigInteger bigIntModulus = new BigInteger(modulus);
            BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(bigIntModulus, bigIntPrivateExponent);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            return privateKey;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /** * 打印公鑰信息 * * @param publicKey */
    public static String public_encode = "";

    public static String printPublicKeyInfo(PublicKey publicKey) {
        RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
        System.out.println("----------RSAPublicKey----------");
        System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());
        System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());
        byte[] byteArray = rsaPublicKey.getModulus().toByteArray();
        System.out.println(Util.bytes2Hex(byteArray));

        String pk = "30819F300D06092A864886F70D010101050003818D00308189028181" + Util.bytes2Hex(byteArray) + "0203010001";
        public_encode = Base64Util.encode(Util.hexToBytes(pk));
        System.out.println("公鑰=" + public_encode);

        System.out.println("byteArray=" + byteArray.length);

        System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());
        System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());
        return rsaPublicKey.getModulus().toString();
    }

    public static String printPrivateKeyInfo(PrivateKey privateKey) {
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
        System.out.println("----------RSAPrivateKey ----------");
        System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());
        System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());
        System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());
        System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());
        return rsaPrivateKey.getPrivateExponent().toString();

    }
 }
     
     
     

    

1. C端生成RSA密鑰對，java端進行公鑰加密，C端進行RSA加密；
2. 首先在C端生成RSA密鑰對，導出公鑰的Modulus，java端獲取到Modulus，調用getPublicKey(byte[] modulus, String publicExponent)生成公鑰，注意：publicExponent一般爲65537，而後調用encryptData(byte[] data, PublicKey publicKey)進行RSA公鑰加密；
3. 這樣加密的數據，C端能夠經過RSA私鑰進行解密。