# 加密算法-对称加密，支持解密;

qq313796269 分享于 2017-07-30

Java 加密解密之对称加密算法PBE PBE是一种基于口令的加密算法，使用口令代替其他对称加密算法中的密钥，其特点在于口令由用户自己掌管，不借助任何物理媒体；采

# 第一次改造

``` 1         /// <summary>
2         /// AES 对称加密
3         /// </summary>
4         /// <param name="str"></param>
5         /// <param name="kk"></param>
6         /// <returns></returns>
7         public static String Convert_AES(String str)
8         {
9             char[] strChars = str.ToCharArray();
10             /*二分对称性*/
11             int fcount = strChars.Length / 2;
12             /*间隔一个字符，替换*/
13             for (int i = 0; i < fcount; i += 2)
14             {
15                 /*对称处理*/
16                 char tmp = strChars[i];
17                 strChars[i] = strChars[fcount + i];
18                 strChars[fcount + i] = tmp;
19             }
20             return new String(strChars);
21         }```

# 第二次改造

``` 1         /// <summary>
2         /// AES 对称加密
3         /// </summary>
4         /// <param name="str"></param>
5         /// <param name="kk"></param>
6         /// <returns></returns>
7         public static String Convert_AES(String str, int kk)
8         {
9             char[] strChars = str.ToCharArray();
10             /*二分对称性*/
11             int fcount = strChars.Length / 2;
12             /*间隔一个字符，替换*/
13             for (int i = 0; i < fcount; i += kk)
14             {
15                 /*对称处理*/
16                 char tmp = strChars[i];
17                 strChars[i] = strChars[fcount + i];
18                 strChars[fcount + i] = tmp;
19             }
20             return new String(strChars);
21         }```

# 第三次改造

``` 1         /// <summary>
2         /// AES 对称加密
3         /// </summary>
4         /// <param name="str"></param>
5         /// <param name="kk"></param>
6         /// <returns></returns>
7         public static String Convert_AES(String str, params int[] kk)
8         {
9             char[] strChars = str.ToCharArray();
10             /*二分对称性*/
11             int fcount = strChars.Length / 2;
12             /*对称性 k 值*/
13             foreach (int k in kk)
14             {
15                 /*间隔一个字符，替换*/
16                 for (int i = 0; i < fcount; i += k)
17                 {
18                     /*对称处理*/
19                     char tmp = strChars[i];
20                     strChars[i] = strChars[fcount + i];
21                     strChars[fcount + i] = tmp;
22                 }
23             }
24             return new String(strChars);
25         }```

# 第四次改造

``` 1         /// <summary>
2         /// AES 对称加密
3         /// </summary>
4         /// <param name="str"></param>
5         /// <param name="kk"></param>
6         /// <returns></returns>
7         public static String Convert_In_AES(String str, params int[] kk)
8         {
9             byte[] bytes = Encoding.UTF8.GetBytes(str);
10             long arrayLength = (long)((4.0d / 3.0d) * bytes.Length);
11             // 如果数组长度不可被4整除，则增加.
12             if (arrayLength % 4 != 0)
13             {
14                 arrayLength += 4 - arrayLength % 4;
15             }
16
17             char[] base64CharArray = new char[arrayLength];
18             /*优先转化base64*/
19             Convert.ToBase64CharArray(bytes, 0, bytes.Length, base64CharArray, 0);
20             /*再加密*/
21             return new String(Convert_AES(base64CharArray, kk));
22         }
23
24         /// <summary>
25         /// AES 对称加密
26         /// </summary>
27         /// <param name="str"></param>
28         /// <param name="kk"></param>
29         /// <returns></returns>
30         public static String Convert_Un_AES(String str, params int[] kk)
31         {
32             char[] charArray = str.ToCharArray();
33             /*先解密*/
34             charArray = Convert_AES(charArray);
35             /*转化base64*/
36             byte[] bytes = Convert.FromBase64CharArray(charArray, 0, charArray.Length);
37             return Encoding.UTF8.GetString(bytes);
38         }
39
40
41         /// <summary>
42         /// AES 对称加密
43         /// </summary>
44         /// <param name="str"></param>
45         /// <param name="kk"></param>
46         /// <returns></returns>
47         public static char[] Convert_AES(char[] strChars, params int[] kk)
48         {
49             /*二分对称性*/
50             int fcount = strChars.Length / 2;
51             /*对称性 k 值*/
52             foreach (int k in kk)
53             {
54                 /*间隔一个字符，替换*/
55                 for (int i = 0; i < fcount; i += k)
56                 {
57                     /*对称处理*/
58                     char tmp = strChars[i];
59                     strChars[i] = strChars[fcount + i];
60                     strChars[fcount + i] = tmp;
61                 }
62             }
63             return strChars;
64         }```

```1             /*加密的对称属性*/
2             Convert_In_AES("1234567890agasdgasfas案发后暗哨", 3, 2, 5, 6);
3             /*解密的对称属性*/
4             Convert_Un_AES("1234567890agasdgasfas案发后暗哨", 6, 5, 2, 3);```

```  1     private static final Base64.Encoder BASE64_ENCODER = java.util.Base64.getEncoder();
2
3     /**
4      * 编码64位
5      *
6      * @param str
7      * @return
8      */
9     public static String convertToBase64String(String str) {
10         try {
11             return BASE64_ENCODER.encodeToString(str.getBytes("utf-8"));
12         } catch (Exception e) {
13             throw new UnsupportedOperationException(e);
14         }
15     }
16
17     /**
18      * 编码64位
19      *
20      * @param str
21      * @return
22      */
23     public static byte[] convertToBase64Byte(String str) {
24         try {
25             return BASE64_ENCODER.encode(str.getBytes("utf-8"));
26         } catch (Exception e) {
27             throw new UnsupportedOperationException(e);
28         }
29     }
30
31     /**
32      * 编码64位
33      *
34      * @param str
35      * @return
36      */
37     public static String convertToBase64String(byte[] str) {
38         return BASE64_ENCODER.encodeToString(str);
39     }
40
41     /**
42      * 编码64位
43      *
44      * @param str
45      * @return
46      */
47     public static byte[] convertToBase64Byte(byte[] str) {
48         return BASE64_ENCODER.encode(str);
49     }
50
51     private static final Base64.Decoder Base64_DECODER = java.util.Base64.getDecoder();
52
53     /**
54      * 解码64位
55      *
56      * @param str
57      * @return
58      */
59     public static byte[] convertFromBase64Byte(String str) {
60         return Base64_DECODER.decode(str);
61     }
62
63     /**
64      * 解码64位
65      *
66      * @param str
67      * @return
68      */
69     public static String convertFromBase64(String str) {
70         try {
71             return new String(StringUtil.convertFromBase64Byte(str), "utf-8");
72         } catch (Exception e) {
73             throw new UnsupportedOperationException(e);
74         }
75     }
76
77     /**
78      * 解码64位
79      *
80      * @param str
81      * @return
82      */
83     public static byte[] convertFromBase64Byte(byte[] str) {
84         return Base64_DECODER.decode(str);
85     }
86
87     /**
88      * 解码64位
89      *
90      * @param str
91      * @return
92      */
93     public static String convertFromBase64(byte[] str) {
94         try {
95             return new String(convertFromBase64Byte(str), "utf-8");
96         } catch (Exception e) {
97             throw new UnsupportedOperationException(e);
98         }
99     }
100
101     /**
102      * ASE 对称加密
103      *
104      * @param str 需要加密的字符串
105      * @param kk 对称加密顺序
106      * @return
107      */
108     public static String convert_InBase64_ASE(String str, int... kk) {
109         char[] strChars = convertToBase64String(str).toCharArray();
110         return convert_ASE_ToCharString(strChars, kk);
111     }
112
113     /**
114      * ASE 对称加密
115      *
116      * @param str 需要加密的字符串
117      * @param kk 对称加密顺序
118      * @return
119      */
120     public static String convert_UnBase64_ASE(String str, int... kk) {
121         String convert_ASE = convert_ASE(str, kk);
122         return convertFromBase64(convert_ASE);
123     }
124
125     /**
126      * ASE 对称加密
127      *
128      * @param str 需要加密的字符串
129      * @param kk 对称加密顺序
130      * @return
131      */
132     public static String convert_ASE(String str, int... kk) {
133         char[] strChars = str.toCharArray();
134         return convert_ASE_ToCharString(strChars, kk);
135     }
136
137     /**
138      * ASE 对称加密
139      *
140      * @param strChars 需要加密的字符串
141      * @param kk 对称加密顺序
142      * @return
143      */
144     public static String convert_ASE_ToCharString(char[] strChars, int... kk) {
145         try {
146             return new String(convert_ASE_ToChar(strChars, kk));
147         } catch (Exception e) {
148             throw new UnsupportedOperationException(e);
149         }
150     }
151
152     /**
153      * ASE 对称加密
154      *
155      * @param strChars 需要加密的字符串
156      * @param kk 对称加密顺序
157      * @return
158      */
159     public static char[] convert_ASE_ToChar(char[] strChars, int... kk) {
160         /*二分对称性*/
161         int fcount = strChars.length / 2;
162         /*对称性 k 值*/
163         for (int k : kk) {
164             for (int i = 0; i < fcount; i += k) {
165                 /*对称处理*/
166                 char tmp = strChars[i];
167                 strChars[i] = strChars[fcount + i];
168                 strChars[fcount + i] = tmp;
169             }
170         }
171         return strChars;
172     }```

# 总结

U3D程序运行在手机设备上，字符处理也是比较消耗性能的；

下面用DES对称加密算法（设定一个密钥，然后对所有的数据进行加密）来简单举个例子。 首先，生成一个密钥KEY。 我把它保存到key.txt中。这个文件就象是一把钥

×
• 登录
• 注册

×