Android RSA和AES对称加密工具

作者：从前慢现在也慢 | 2024-04-24 07:00:53

踩

android rsa

前言

最近开发用到数据加密研究后要用RSA和AES对称加密工具
以前没搞过记录一下心酸过程

说明

客户端和服务端的加密代码是不同的即使都是java语言只有一些模式和参数需要同步设置
比如字节码和加密模式

RSAUtils

package com.mob.common.utils;


import android.util.Base64;

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
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;

/**
 * RSA加密工具
 */
public class RSAUtils {

    //构建Cipher实例时所传入的的字符串，默认为"RSA/NONE/PKCS1Padding"
    private static String sTransform = "RSA/NONE/PKCS1Padding";

    //进行Base64转码时的flag设置，默认为Base64.DEFAULT
    private static int sBase64Mode = Base64.DEFAULT;

    //初始化方法，设置参数
    public static void init(String transform, int base64Mode) {
        sTransform = transform;
        sBase64Mode = base64Mode;
    }


    /*
        产生密钥对
        @param keyLength
        密钥长度，小于1024长度的密钥已经被证实是不安全的，通常设置为1024或者2048，建议2048
     */
    public static KeyPair generateRSAKeyPair(int keyLength) {
        KeyPair keyPair = null;
        try {

            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            //设置密钥长度
            keyPairGenerator.initialize(keyLength);
            //产生密钥对
            keyPair = keyPairGenerator.generateKeyPair();

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }

        return keyPair;
    }

    /*
        加密或解密数据的通用方法
        @param srcData
        待处理的数据
        @param key
        公钥或者私钥
        @param mode
        指定是加密还是解密，值为Cipher.ENCRYPT_MODE或者Cipher.DECRYPT_MODE

     */
    private static byte[] processData(byte[] srcData, Key key, int mode) {

        //用来保存处理结果
        byte[] resultBytes = null;

        try {

            //获取Cipher实例
            Cipher cipher = Cipher.getInstance(sTransform);
            //初始化Cipher，mode指定是加密还是解密，key为公钥或私钥
            cipher.init(mode, key);
            //处理数据
            resultBytes = cipher.doFinal(srcData);

        } catch (NoSuchAlgorithmException
         | NoSuchPaddingException | InvalidKeyException 
         | BadPaddingException | IllegalBlockSizeException e) {
            e.printStackTrace();
        }

        return resultBytes;
    }


    /*
        使用公钥加密数据，结果用Base64转码
     */
    public static String encryptDataByPublicKey(byte[] srcData, PublicKey publicKey) {

        byte[] resultBytes = processData(srcData, publicKey, Cipher.ENCRYPT_MODE);
        if (resultBytes != null && resultBytes.length > 0) {
            return Base64.encodeToString(resultBytes, sBase64Mode);
        }

        return "";

    }

    /*
        使用私钥解密，返回解码数据
     */
    public static byte[] decryptDataByPrivate(String encryptedData, PrivateKey privateKey) {

        byte[] bytes = Base64.decode(encryptedData, sBase64Mode);

        return processData(bytes, privateKey, Cipher.DECRYPT_MODE);
    }

    /*
        使用私钥进行解密，解密数据转换为字符串，使用utf-8编码格式
     */
    public static String decryptedToStrByPrivate(String encryptedData, PrivateKey privateKey) {
        return new String(decryptDataByPrivate(encryptedData, privateKey));
    }

    /*
        使用私钥解密，解密数据转换为字符串，并指定字符集
     */
    public static String decryptedToStrByPrivate(String encryptedData, PrivateKey privateKey, String charset) {
        try {

            return new String(decryptDataByPrivate(encryptedData, privateKey), charset);

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return null;
    }


    /*
        使用私钥加密，结果用Base64转码
     */

    public static String encryptDataByPrivateKey(byte[] srcData, PrivateKey privateKey) {

        byte[] resultBytes = processData(srcData, privateKey, Cipher.ENCRYPT_MODE);

        return Base64.encodeToString(resultBytes, sBase64Mode);
    }

    /*
        使用公钥解密，返回解密数据
     */

    public static byte[] decryptDataByPublicKey(String encryptedData, PublicKey publicKey) {

        byte[] bytes = Base64.decode(encryptedData, sBase64Mode);

        return processData(bytes, publicKey, Cipher.DECRYPT_MODE);

    }

    /*
        使用公钥解密，结果转换为字符串，使用默认字符集utf-8
     */
    public static String decryptedToStrByPublicKey(String encryptedData, PublicKey publicKey) {
        return new String(decryptDataByPublicKey(encryptedData, publicKey));
    }


    /*
        使用公钥解密，结果转换为字符串，使用指定字符集
     */

    public static String decryptedToStrByPublicKey(String encryptedData, PublicKey publicKey, String charset) {
        try {

            return new String(decryptDataByPublicKey(encryptedData, publicKey), charset);

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        return null;
    }




    /*
        将字符串形式的公钥转换为公钥对象
     */

    public static PublicKey keyStrToPublicKey(String publicKeyStr) {

        PublicKey publicKey = null;

        byte[] keyBytes = Base64.decode(publicKeyStr, sBase64Mode);

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

        try {

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            publicKey = keyFactory.generatePublic(keySpec);

        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            e.printStackTrace();
        }

        return publicKey;

    }

    /*
        将字符串形式的私钥，转换为私钥对象
     */

    public static PrivateKey keyStrToPrivate(String privateKeyStr) {

        PrivateKey privateKey = null;

        byte[] keyBytes = Base64.decode(privateKeyStr, sBase64Mode);

        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

        try {

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            privateKey = keyFactory.generatePrivate(keySpec);

        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
            e.printStackTrace();
        }

        return privateKey;

    }

}

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

AESUtils

package com.mob.common.utils;


import android.util.Base64;


import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;


import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

/**
 * AES加密工具
 */
public class AESUtils {

    /**
     * 加密算法
     */
    private static final String KEY_ALGORITHM = "AES";

    /**
     * AES 的 密钥长度，32 字节，范围：16 - 32 字节
     */
    public static final int SECRET_KEY_LENGTH = 16;

    /**
     * 字符编码
     */
    private static final Charset CHARSET_UTF8 = StandardCharsets.UTF_8;

    /**
     * 秘钥长度不足 16 个字节时，默认填充位数
     */
    private static final String DEFAULT_VALUE = "0";
    /**
     * 加解密算法/工作模式/填充方式
     */
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";

    /**
     * AES 加密
     *
     * @param data      待加密内容
     * @param secretKey 加密密码，长度：16 或 32 个字符
     * @return 返回Base64转码后的加密数据
     */
    public static String encrypt(String data, String secretKey) {
        try {
            //创建密码器
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            //初始化为加密密码器
            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(secretKey));
            byte[] encryptByte = cipher.doFinal(data.getBytes(CHARSET_UTF8));
            // 将加密以后的数据进行 Base64 编码
            return base64Encode(encryptByte);
        } catch (Exception e) {
            handleException(e);
        }
        return null;
    }

    /**
     * AES 解密
     *
     * @param base64Data 加密的密文 Base64 字符串
     * @param secretKey  解密的密钥，长度：16 或 32 个字符
     */
    public static String decrypt(String base64Data, String secretKey) {
        try {
            byte[] data = base64Decode(base64Data);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            //设置为解密模式
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(secretKey));
            //执行解密操作
            byte[] result = cipher.doFinal(data);
            return new String(result, CHARSET_UTF8);
        } catch (Exception e) {
            handleException(e);
        }
        return null;
    }

    /**
     * 使用密码获取 AES 秘钥
     */
    public static SecretKeySpec getSecretKey(String secretKey) {
        secretKey = toMakeKey(secretKey, SECRET_KEY_LENGTH, DEFAULT_VALUE);
        return new SecretKeySpec(secretKey.getBytes(CHARSET_UTF8), KEY_ALGORITHM);
    }

    /**
     * 如果 AES 的密钥小于 {@code length} 的长度，就对秘钥进行补位，保证秘钥安全。
     *
     * @param secretKey 密钥 key
     * @param length    密钥应有的长度
     * @param text      默认补的文本
     * @return 密钥
     */
    private static String toMakeKey(String secretKey, int length, String text) {
        // 获取密钥长度
        int strLen = secretKey.length();
        // 判断长度是否小于应有的长度
        if (strLen < length) {
            // 补全位数
            StringBuilder builder = new StringBuilder();
            // 将key添加至builder中
            builder.append(secretKey);
            // 遍历添加默认文本
            for (int i = 0; i < length - strLen; i++) {
                builder.append(text);
            }
            // 赋值
            secretKey = builder.toString();
        }
        return secretKey;
    }

    /**
     * 将 Base64 字符串 解码成 字节数组
     */
    public static byte[] base64Decode(String data) {
        return Base64.decode(data, Base64.NO_WRAP);
    }

    /**
     * 将 字节数组 转换成 Base64 编码
     */
    public static String base64Encode(byte[] data) {
        return Base64.encodeToString(data, Base64.NO_WRAP);
    }

    /**
     * 处理异常
     */
    private static void handleException(Exception e) {
        e.printStackTrace();
    }


}

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

测试代码

    //字符串公钥
    public static final String PUBLIC_KEY_STR = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDHhR8P0HdnoXXvgeH2DIIxHWrI\n" +
            "bfH4+rr3sqJ5z/mkBcYu7+n2f74CZABZGXyNyVMZgGB8giPKijBxjZuMAevqHxuR\n" +
            "Yi22DxyOnP3kQXQVaHv9XukPpZXpDsxj6jb1ngy8rRrw2Zb1ofGLDicM2IVB9Ma8\n" +
            "G8wdIPu10qrVytYsLwIDAQAB";

    //字符串密钥
    public static final String PRIVATE_KEY_STR = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJK3E8oqdY/AfV71/Dx+RaYhTV52hdkPgPfTAAyvH5doQvHG0WrgfGoona410P45/6NJ8w02BTWaU3wOwBR082mnmNk18edwb2vi+2RrYhO4micTfNRq5jFwapvh+FqYCJLe1VDWNwQtdLaf7b7OrqG9sZ2vMDyw8bujhdRkOvenAgMBAAECgYAZspV1yKAU0Ltk4aMPmXJrmdOqYwoorc2CGuQcVKQs6ecn4BIYLT+9fGW5+NUlYlVDbZVzz+1zqRdMWG0OaDmmFoyqzZ0te+vwekzdniCBkGK+1i9nSyR6ix9zdmXLxPlh4qxYZ0kiBwPtCKsb1RddlmBEneMGiCtLxe62b0TmQQJBAP1UGTiMOPi+X4i2/PTfBC99fKv/6trXmcczgdJmdS9ThfsO3y9sQbIdwXaR/z6eBKCLb9QYYrNSrFeWUZHj9KECQQCUQyifZXqGYP+5fMMZsKE2RuZf8dQ1OknK73S+EvlaDTvmd/DNGB3v9Kxmh0rJgmdUA6gK9drEVRYuxs1rvr9HAkBHCfBQpTHMv0X3BqmE2Y1I6/2sFgX7/H3JGK6NG+I8tUVbE96OY+NAWYvI/kP/gTx28OMZLQVwl/xwS1zwdmZBAkAn08ak0vjQAlyPslEipI0Z7H/URD0yMz9BcYPVz3kGVMnDhnK8VX8tR3fMbwmLCinBqt3IW/Txir3TwPnLuMjfAkAcbOPSFt0ebHYdKU9aeoFsBnDycT7GYYLWl4h1bZ+TAWcsnp46s1IJLVPIscwOOlIsxgd2+OX2OOSgxXPlT3RD";

    public static final String CONTENT = "TI3b7oglaExMRLZ+2XZrNBW+ExMmbPk+Js9SAKt4xuf1UfGrYIYInQkMUPIt1D4QnOyvnblUfle54B9/IAMNefban5IRBmh4dPKd/c7yqVIGPzWeVujfWJZjFw8owNX0gwNcixb7fbIDk16ZRpZHoqtHLsCzMLljCMYHqHhkwY4=";
               /**
                 * Rsa测试代码
                 */
                String s = RSAUtils.decryptedToStrByPrivate(CONTENT, RSAUtils.keyStrToPrivate(PRIVATE_KEY_STR));
                Log.e("RSA解密：", s);            

                //获取公钥
                PublicKey publicKey = RSAUtils.keyStrToPublicKey(PUBLIC_KEY_STR);
                //获取私钥
                PrivateKey privateKey = RSAUtils.keyStrToPrivate(PRIVATE_KEY_STR);

                //需要加密的数据
                String clearText01 = "123";

                //公钥加密结果
                String publicEncryptedResult = RSAUtils.encryptDataByPublicKey(clearText01.getBytes(), publicKey);
                //私钥解密结果
                String privateDecryptedResult = RSAUtils.decryptedToStrByPrivate(publicEncryptedResult, privateKey);

                Logger.d("公钥加密，私钥解密测试：\n"
                        + "原文:\n" + clearText01 + "\n"
                        + "公钥加密结果:\n" + publicEncryptedResult + "\n"
                        + "私钥解密结果:\n" + privateDecryptedResult
                );


                //需要加密的数据
                String clearText02 = "456";
                //私钥加密结果
                String privateEncryptedResult = RSAUtils.encryptDataByPrivateKey(clearText02.getBytes(), privateKey);
                //公钥解密结果
                String publicDecryptedResult = RSAUtils.decryptedToStrByPublicKey(privateEncryptedResult, publicKey);

                Logger.d("私钥加密，公钥解密测试：\n"
                        + "原文：\n" + clearText02 + "\n"
                        + "私钥加密结果:\n" + privateEncryptedResult + "\n"
                        + "公钥解密结果:\n" + publicDecryptedResult
                );


                /**
                 * AES测试代码
                 */
                try {
                    String encrypt = AESUtils.decrypt( "jpgg/hUUtntX3D6VAnA7LWw9eGkdfp1WIjtBKnOWOjY=","wyq6hxm1cqmq4w8r");
                    Log.e("AES-解密：", encrypt);

                } catch (Exception e) {
                    e.printStackTrace();
                }

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/478131