前端对称加密--js对用户名密码进行DES加密

                       

周末在家里整理一下之前写的网站中对登录的用户名和密码进行加密的过程。

在网上有很多DES加密的js版，有一些是用java解密不成功的，今天分享一个前端用js的DES加密，后端使用java版的DES解密

因为要在后台进行解密，所以采用对称加密。

对称加密可以选择很多，这里选择的DES加密。

前端采用谷歌的crypto-js

直接上代码

前端需要引入的js

    <script type="text/javascript" src="js/jquery.min.js" ></script>    <script type="text/javascript" src="js/tripledes.js" ></script>    <script type="text/javascript" src="js/mode-ecb.js" ></script>
  
  
1
2
3

CryptoJS v3.1.2.zip下载

关键方法

js班DES加密

// DES加密function encryptByDES(message, key) {    var keyHex = CryptoJS.enc.Utf8.parse(key);    var encrypted = CryptoJS.DES.encrypt(message, keyHex, {        mode: CryptoJS.mode.ECB,        padding: CryptoJS.pad.Pkcs7    });    return encrypted.toString();}
  
  
1
2
3
4
5
6
7
8
9

我们对helloworld进行DES加密，key设置为12345678

加密后的结果为

ovATL3QOQmKh0WiTqhkSbg==

后台采用java版本的DES解密

java版的DES工具类

DESUtil.java

import java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;import java.security.spec.InvalidKeySpecException;import javax.crypto.BadPaddingException;import javax.crypto.Cipher;import javax.crypto.IllegalBlockSizeException;import javax.crypto.NoSuchPaddingException;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;/** * DES加解密工具类 *  * @author 程高伟 * * @date 2016年6月15日 上午10:02:50 */public class DESUtil {    private static final String DES_ALGORITHM = "DES";    /**     * DES加密     *      * @param plainData 原始字符串     * @param secretKey 加密密钥     * @return 加密后的字符串     * @throws Exception     */    public static String encryption(String plainData, String secretKey) throws Exception {        Cipher cipher = null;        try {            cipher = Cipher.getInstance(DES_ALGORITHM);            cipher.init(Cipher.ENCRYPT_MODE, generateKey(secretKey));        } catch (NoSuchAlgorithmException e) {            e.printStackTrace();        } catch (NoSuchPaddingException e) {            e.printStackTrace();        } catch (InvalidKeyException e) {        }        try {            // 为了防止解密时报javax.crypto.IllegalBlockSizeException: Input length must            // be multiple of 8 when decrypting with padded cipher异常，            // 不能把加密后的字节数组直接转换成字符串            byte[] buf = cipher.doFinal(plainData.getBytes());            return Base64Utils.encode(buf);        } catch (IllegalBlockSizeException e) {            e.printStackTrace();            throw new Exception("IllegalBlockSizeException", e);        } catch (BadPaddingException e) {            e.printStackTrace();            throw new Exception("BadPaddingException", e);        }    }    /**     * DES解密     * @param secretData 密码字符串     * @param secretKey 解密密钥     * @return 原始字符串     * @throws Exception     */    public static String decryption(String secretData, String secretKey) throws Exception {        Cipher cipher = null;        try {            cipher = Cipher.getInstance(DES_ALGORITHM);            cipher.init(Cipher.DECRYPT_MODE, generateKey(secretKey));        } catch (NoSuchAlgorithmException e) {            e.printStackTrace();            throw new Exception("NoSuchAlgorithmException", e);        } catch (NoSuchPaddingException e) {            e.printStackTrace();            throw new Exception("NoSuchPaddingException", e);        } catch (InvalidKeyException e) {            e.printStackTrace();            throw new Exception("InvalidKeyException", e);        }        try {            byte[] buf = cipher.doFinal(Base64Utils.decode(secretData.toCharArray()));            return new String(buf);        } catch (IllegalBlockSizeException e) {            e.printStackTrace();            throw new Exception("IllegalBlockSizeException", e);        } catch (BadPaddingException e) {            e.printStackTrace();            throw new Exception("BadPaddingException", e);        }    }    /**     * 获得秘密密钥     *      * @param secretKey     * @return     * @throws NoSuchAlgorithmException     * @throws InvalidKeySpecException     * @throws InvalidKeyException     */    private static SecretKey generateKey(String secretKey)            throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException {        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM);        DESKeySpec keySpec = new DESKeySpec(secretKey.getBytes());        keyFactory.generateSecret(keySpec);        return keyFactory.generateSecret(keySpec);    }    static private class Base64Utils {        static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="                .toCharArray();        static private byte[] codes = new byte[256];        static {            for (int i = 0; i < 256; i++)                codes[i] = -1;            for (int i = 'A'; i <= 'Z'; i++)                codes[i] = (byte) (i - 'A');            for (int i = 'a'; i <= 'z'; i++)                codes[i] = (byte) (26 + i - 'a');            for (int i = '0'; i <= '9'; i++)                codes[i] = (byte) (52 + i - '0');            codes['+'] = 62;            codes['/'] = 63;        }        /**         * 将原始数据编码为base64编码         */        static private String encode(byte[] data) {            char[] out = new char[((data.length + 2) / 3) * 4];            for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {                boolean quad = false;                boolean trip = false;                int val = (0xFF & (int) data[i]);                val <<= 8;                if ((i + 1) < data.length) {                    val |= (0xFF & (int) data[i + 1]);                    trip = true;                }                val <<= 8;                if ((i + 2) < data.length) {                    val |= (0xFF & (int) data[i + 2]);                    quad = true;                }                out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];                val >>= 6;                out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];                val >>= 6;                out[index + 1] = alphabet[val & 0x3F];                val >>= 6;                out[index + 0] = alphabet[val & 0x3F];            }            return new String(out);        }        /**         * 将base64编码的数据解码成原始数据         */        static private byte[] decode(char[] data) {            int len = ((data.length + 3) / 4) * 3;            if (data.length > 0 && data[data.length - 1] == '=')                --len;            if (data.length > 1 && data[data.length - 2] == '=')                --len;            byte[] out = new byte[len];            int shift = 0;            int accum = 0;            int index = 0;            for (int ix = 0; ix < data.length; ix++) {                int value = codes[data[ix] & 0xFF];                if (value >= 0) {                    accum <<= 6;                    shift += 6;                    accum |= value;                    if (shift >= 8) {                        shift -= 8;                        out[index++] = (byte) ((accum >> shift) & 0xff);                    }                }            }            if (index != out.length)                throw new Error("miscalculated data length!");            return out;        }    }}
  
  
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