在日常设计及开发中，为确保数据传输和数据存储的安全，可通过特定的算法，将数据明文加密成复杂的密文。目前主流加密手段大致可分为单向加密和双向加密。
单向加密：通过对数据进行摘要计算生成密文，密文不可逆推还原。算法代表：Base64，MD5，SHA;
双向加密：与单向加密相反，可以把密文逆推还原成明文，双向加密又分为对称加密和非对称加密。
对称加密：指数据使用者必须拥有相同的密钥才可以进行加密解密，就像彼此约定的一串暗号。算法代表：DES，3DES，AES，IDEA，RC4，RC5;
非对称加密：相对对称加密而言，无需拥有同一组密钥，非对称加密是一种“信息公开的密钥交换协议”。非对称加密需要公开密钥和私有密钥两组密钥，公开密钥和私有密钥是配对起来的，也就是说使用公开密钥进行数据加密，只有对应的私有密钥才能解密。这两个密钥是数学相关，用某用户密钥加密后的密文，只能使用该用户的加密密钥才能解密。如果知道了其中一个，并不能计算出另外一个。因此如果公开了一对密钥中的一个，并不会危害到另外一个密钥性质。这里把公开的密钥为公钥，不公开的密钥为私钥。算法代表：RSA，DSA。
======================================================
3DES算法
3DES是三重数据加密，且可以逆推的一种算法方案。但由于3DES的算法是公开的，所以算法本身没有密钥可言，主要依靠唯一密钥来确保数据加解密的安全。到目前为止，仍没有人能破解3DES。
3DES(或称为Triple DES)是三重数据加密算法(TDEA，Triple Data Encryption Algorithm)块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解;3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。
3DES加解密工具类
1 package tqx.demo;
2
3
4
5 import java.net.URLDecoder;
6 import java.net.URLEncoder;
7 import java.security.Key;
8
9 import javax.crypto.Cipher;
10 import javax.crypto.SecretKeyFactory;
11 import javax.crypto.spec.DESedeKeySpec;
12 import javax.crypto.spec.IvParameterSpec;
13
14 import com.alibaba.fastjson.JSONObject;
15
16 /**
17 * 3DES加密工具类
18 *
19 */
20 public class INITDES3Util {
21 // 密钥
22 private static String SECRETKEY = "INbSvyvOTkSkcRNSc8HpHIat";
23 // 向量
24 private static String IV = "drS66rwt";
25 // 加解密统一使用的编码方式
26 private final static String encoding = "utf-8";
27
28 public INITDES3Util(String s,String v ){
29 this.SECRETKEY=s;
30 this.IV=v;
31 }
32
33 /**
34 * 3DES加密
35 *
36 * @param plainText
37 * 普通文本
38 * @return
39 */
40 public String encrypt(String plainText) throws Exception {
41 Key deskey = null;
42 DESedeKeySpec spec = new DESedeKeySpec(SECRETKEY.getBytes());
43 SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
44 deskey = keyfactory.generateSecret(spec);
45
46 Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
47 IvParameterSpec ips = new IvParameterSpec(IV.getBytes());
48 cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
49 byte[] encryptData = cipher.doFinal(plainText.getBytes(encoding));
50 return Base64.encode(encryptData);
51 }
52
53 /**
54 * 3DES解密
55 *
56 * @param encryptText
57 * 加密文本
58 * @return
59 */
60 public String decrypt(String encryptText) throws Exception {
61 Key deskey = null;
62 DESedeKeySpec spec = new DESedeKeySpec(SECRETKEY.getBytes());
63 SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
64 deskey = keyfactory.generateSecret(spec);
65 Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
66 IvParameterSpec ips = new IvParameterSpec(IV.getBytes());
67 cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
68
69 byte[] decryptData = cipher.doFinal(Base64.decode(encryptText));
70
71 return new String(decryptData, encoding);
72 }
73
74 /**
75 * 3DES加密
76 *
77 * @param secretKey
78 * 秘钥
79 * @param iv
80 * 偏移向量
81 * @param plainText
82 * 普通文本
83 * @return
84 * @throws Exception
85 */
86 public static String encryptString(String secretKey, String iv,
87 String plainText) throws Exception {
88 Key deskey = null;
89 DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
90 SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
91 deskey = keyfactory.generateSecret(spec);
92
93 Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
94 IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
95 cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
96 byte[] encryptData = cipher.doFinal(plainText.getBytes(encoding));
97 return Base64.encode(encryptData);
98 }
99
100 /**
101 * 3DES解密
102 *
103 * @param secretKey
104 * 秘钥
105 * @param iv
106 * 偏移向量
107 * @param encryptText
108 * 密文
109 * @return
110 * @throws Exception
111 */
112 public static String decryptString(String secretKey, String iv,
113 String encryptText) throws Exception {
114 Key deskey = null;
115 DESedeKeySpec spec = new DESedeKeySpec(secretKey.getBytes());
116 SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
117 deskey = keyfactory.generateSecret(spec);
118 Cipher cipher = Cipher.getInstance("desede/CBC/PKCS5Padding");
119 IvParameterSpec ips = new IvParameterSpec(iv.getBytes());
120 cipher.init(Cipher.DECRYPT_MODE, deskey, ips);
121
122 byte[] decryptData = cipher.doFinal(Base64.decode(encryptText));
123
124 return new String(decryptData, encoding);
125 }
126
127 /**
128 * 3DES解码后解密
129 *
130 * @param secretKey
131 * 秘钥
132 * @param iv
133 * 偏移向量
134 * @param encryptText
135 * 密文
136 * @return
137 * @throws Exception
138 */
139 public static String decryptStringURLDecoder(String secretKey, String iv,
140 String encryptText) throws Exception {
141 String retJsonStr = decryptString(secretKey, iv,
142 URLDecoder.decode(encryptText));
143 return retJsonStr;
144 }
145
146 /**
147 * URLEncoder编码加密信息
148 *
149 * @param secretKey
150 * @param iv
151 * @param plainText
152 * @return
153 * @throws Exception
154 */
155 public static String encryptStringURLEncoder(String secretKey, String iv,
156 String plainText) throws Exception {
157 String base64Str = encryptString(secretKey, iv, plainText);
158 return URLEncoder.encode(base64Str);
159 }
160
161
162 public static void main(String[] args) throws Exception {
163 String result="";
164 INITDES3Util desSource=new INITDES3Util("INbSvyvOTkSkcRNSc8HpHIat","drS66rwt");
165 //JSONObject outData = new JSONObject();
166 //JSONObject resultOutData = new JSONObject();
167 String outputStr="123456";
168 String para=desSource.encrypt(outputStr);//加密json串
169 System.out.println(para);
170 String decryptString = INITDES3Util.encryptString("INbSvyvOTkSkcRNSc8HpHIat","drS66rwt", "sysadmin");
171 System.out.println(decryptString);
172
173 }
174
175 }
URLDecoder类包含一个decode(String s,String charcter)静态方法,它可以将看上去乱码的特殊字符串转换成普通字符串
URLEncoder类包含一个encode(String s,String charcter)静态方法,它可以将普通字符串转换成application/x-www-form-urlencoded MIME字符串
base64
1 package tqx.demo;
2
3
4 import java.io.ByteArrayOutputStream;
5 import java.io.IOException;
6 import java.io.OutputStream;
7
8 /**
9 * Base64编码工具类
10 *
11 */
12 public class Base64 {
13 private static final char[] legalChars =
14
15 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
16 .toCharArray();
17
18 public static String encode(byte[] data) {
19 int start = 0;
20 int len = data.length;
21 StringBuffer buf = new StringBuffer(data.length * 3 /
22
23 2);
24
25 int end = len - 3;
26 int i = start;
27 int n = 0;
28
29 while (i <= end) {
30 int d = ((((int) data[i]) & 0x0ff) << 16)
31 | ((((int) data[i + 1]) & 0x0ff)
32
33 << 8)
34 | (((int) data[i + 2]) & 0x0ff);
35
36 buf.append(legalChars[(d >> 18) & 63]);
37 buf.append(legalChars[(d >> 12) & 63]);
38 buf.append(legalChars[(d >> 6) & 63]);
39 buf.append(legalChars[d & 63]);
40
41 i += 3;
42
43 if (n++ >= 14) {
44 n = 0;
45 buf.append(" ");
46 }
47 }
48
49 if (i == start + len - 2) {
50 int d = ((((int) data[i]) & 0x0ff) << 16)
51 | ((((int) data[i + 1]) & 255)
52
53 << 8);
54
55 buf.append(legalChars[(d >> 18) & 63]);
56 buf.append(legalChars[(d >> 12) & 63]);
57 buf.append(legalChars[(d >> 6) & 63]);
58 buf.append("=");
59 } else if (i == start + len - 1) {
60 int d = (((int) data[i]) & 0x0ff) << 16;
61
62 buf.append(legalChars[(d >> 18) & 63]);
63 buf.append(legalChars[(d >> 12) & 63]);
64 buf.append("==");
65 }
66
67 return buf.toString();
68 }
69
70 private static int decode(char c) {
71 if (c >= 'A' && c <= 'Z')
72 return ((int) c) - 65;
73 else if (c >= 'a' && c <= 'z')
74 return ((int) c) - 97 + 26;
75 else if (c >= '0' && c <= '9')
76 return ((int) c) - 48 + 26 + 26;
77 else
78 switch (c) {
79 case '+':
80 return 62;
81 case '/':
82 return 63;
83 case '=':
84 return 0;
85 default:
86 throw new RuntimeException("unexpectedcode: " + c);
87 }
88 }
89
90 /**
91 * Decodes the given Base64 encoded String to a new byte array.
92
93 The byte
94 * array holding the decoded data is returned.
95 */
96
97 public static byte[] decode(String s) {
98
99 ByteArrayOutputStream bos = new ByteArrayOutputStream();
100 try {
101 decode(s, bos);
102 } catch (IOException e) {
103 throw new RuntimeException();
104 }
105 byte[] decodedBytes = bos.toByteArray();
106 try {
107 bos.close();
108 bos = null;
109 } catch (IOException ex) {
110 System.err.println("Error while decoding BASE64:" + ex.toString());
111 }
112 return decodedBytes;
113 }
114
115 private static void decode(String s, OutputStream os) throws
116
117 IOException {
118 int i = 0;
119
120 int len = s.length();
121
122 while (true) {
123 while (i < len && s.charAt(i) <= ' ')
124 i++;
125
126 if (i == len)
127 break;
128
129 int tri = (decode(s.charAt(i)) << 18)
130 + (decode(s.charAt(i + 1)) <<
131
132 12)
133 + (decode(s.charAt(i + 2)) << 6)
134 + (decode(s.charAt(i + 3)));
135
136 os.write((tri >> 16) & 255);
137 if (s.charAt(i + 2) == '=')
138 break;
139 os.write((tri >> 8) & 255);
140 if (s.charAt(i + 3) == '=')
141 break;
142 os.write(tri & 255);
143
144 i += 4;
145 }
146 }
147 }
测试
package tqx.demo;
public class Demo3 {
public static void main(String[] args) throws Exception {
String encryptStringURLEncoder = INITDES3Util.encryptStringURLEncoder("INbSvyvOTkSkcRNSc8HpHIat", "drS66rwt", "123456");
System.out.println("电话加密后："+encryptStringURLEncoder);
String decryptStringURLDecoder = INITDES3Util.decryptStringURLDecoder("INbSvyvOTkSkcRNSc8HpHIat", "drS66rwt", encryptStringURLEncoder);
System.out.println("电话解密后："+decryptStringURLDecoder);
String encryptStringURLEncoder1 = INITDES3Util.encryptStringURLEncoder("INbSvyvOTkSkcRNSc8HpHIat", "drS66rwt", "tqx");
System.out.println("24加密后："+encryptStringURLEncoder1);
String decryptStringURLDecoder1 = INITDES3Util.decryptStringURLDecoder("INbSvyvOTkSkcRNSc8HpHIat", "drS66rwt", encryptStringURLEncoder1);
System.out.println("24解密后："+decryptStringURLDecoder1);
String encryptStringURLEncoder2 = INITDES3Util.encryptStringURLEncoder("INbSvyvOTkSkcRNSc8HpHIat", "drS66rwt", "512501197203035172");
System.out.println("身份证号加密后："+encryptStringURLEncoder2);
String decryptStringURLDecoder2 = INITDES3Util.decryptStringURLDecoder("INbSvyvOTkSkcRNSc8HpHIat", "drS66rwt", encryptStringURLEncoder2);
System.out.println("身份证号解密后："+decryptStringURLDecoder2);
byte[] decode = Base64.decode("12345600");
System.out.println(decode.toString());
}
}
针对特殊字符的处理 '+'
str.toString()).replaceAll("\\+", "%2B");
// 密钥24位
private static String SECRETKEY = "INbSvyvOTkSkcRNSc8HpHIat";
// 向量6位
private static String IV = "drS66rwt";
生成方法
package tqx.demo;
import java.util.Random;
public class RandomUtil {
public static final String ALLCHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String LETTERCHAR = "abcdefghijkllmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static final String NUMBERCHAR = "0123456789";
/**
* 返回一个定长的带因子的固定的随机字符串(只包含大小写字母、数字)
*
* @param length
* 随机字符串长度
* @return 随机字符串
*/
public static String generateStringByKey(int length, int channel) {
StringBuffer sb = new StringBuffer();
Random random = new Random(channel);
for (int i = 0; i < length; i++) {
sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));
}
return sb.toString();
}
/**
* 返回一个定长的随机字符串(只包含大小写字母、数字)
*
* @param length
* 随机字符串长度
* @return 随机字符串
*/
public static String generateString(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));
}
return sb.toString();
}
/**
* 返回一个定长的随机纯字母字符串(只包含大小写字母)
*
* @param length
* 随机字符串长度
* @return 随机字符串
*/
public static String generateMixString(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(ALLCHAR.charAt(random.nextInt(LETTERCHAR.length())));
}
return sb.toString();
}
/**
* 返回一个定长的随机纯大写字母字符串(只包含大小写字母)
*
* @param length
* 随机字符串长度
* @return 随机字符串
*/
public static String generateLowerString(int length) {
return generateMixString(length).toLowerCase();
}
/**
* 返回一个定长的随机纯小写字母字符串(只包含大小写字母)
*
* @param length
* 随机字符串长度
* @return 随机字符串
*/
public static String generateUpperString(int length) {
return generateMixString(length).toUpperCase();
}
/**
* 生成一个定长的纯0字符串
*
* @param length
* 字符串长度
* @return 纯0字符串
*/
public static String generateZeroString(int length) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < length; i++) {
sb.append('0');
}
return sb.toString();
}
/**
* 根据数字生成一个定长的字符串，长度不够前面补0
*
* @param num
* 数字
* @param fixdlenth
* 字符串长度
* @return 定长的字符串
*/
public static String toFixdLengthString(long num, int fixdlenth) {
StringBuffer sb = new StringBuffer();
String strNum = String.valueOf(num);
if (fixdlenth - strNum.length() >= 0) {
sb.append(generateZeroString(fixdlenth - strNum.length()));
} else {
throw new RuntimeException("将数字" + num + "转化为长度为" + fixdlenth + "的字符串发生异常！");
}
sb.append(strNum);
return sb.toString();
}
/**
* 每次生成的len位数都不相同
*
* @param param
* @return 定长的数字
*/
public static int getNotSimple(int[] param, int len) {
Random rand = new Random();
for (int i = param.length; i > 1; i--) {
int index = rand.nextInt(i);
int tmp = param[index];
param[index] = param[i - 1];
param[i - 1] = tmp;
}
int result = 0;
for (int i = 0; i < len; i++) {
result = result * 10 + param[i];
}
return result;
}
public static void main(String[] args) {
int channel = 555555;// 测试因子比生产因子少1
System.out.println("返回一个定长的带因子的固定的随机字符串(只包含大小写字母、数字):" + generateStringByKey(24, channel));
System.out.println("返回一个定长的随机字符串(只包含大小写字母、数字):" + generateString(24));
System.out.println("返回一个定长的随机纯字母字符串(只包含大小写字母):" + generateMixString(6));
System.out.println("返回一个定长的随机纯大写字母字符串(只包含大小写字母):" + generateLowerString(6));
System.out.println("返回一个定长的随机纯小写字母字符串(只包含大小写字母):" + generateUpperString(6));
System.out.println("生成一个定长的纯0字符串:" + generateZeroString(6));
System.out.println("根据数字生成一个定长的字符串，长度不够前面补0:" + toFixdLengthString(123, 6));
int[] in = { 1, 2, 3, 4, 5, 6, 7 };
System.out.println("每次生成的len位数都不相同:" + getNotSimple(in, 3));
}
}
返回一个定长的带因子的固定的随机字符串(只包含大小写字母、数字):MaigTil28hVETWTssFHGtYDx
返回一个定长的随机字符串(只包含大小写字母、数字):6sBcIpRocWTyBLiKvyNAQ0Sd
返回一个定长的随机纯字母字符串(只包含大小写字母):LLQMLv
返回一个定长的随机纯大写字母字符串(只包含大小写字母):mp6d7s
返回一个定长的随机纯小写字母字符串(只包含大小写字母):MWYWIF
生成一个定长的纯0字符串:000000
根据数字生成一个定长的字符串，长度不够前面补0:000123
每次生成的len位数都不相同:651
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
