本文实例总结了Java常用加密算法。分享给大家供大家参考,具体如下:
项目中第一次深入地了解到加密算法的使用,现第一阶段结束,将使用到的加密算法和大家分享一下:
首先还是先给大家普及一下常用加密算法的基础知识
基本的单向加密算法
BASE64 严格地说,属于编码格式,而非加密算法
MD5(Message Digest algorithm 5,信息摘要算法)
SHA(Secure Hash Algorithm,安全散列算法)
复杂的加密算法
RSA(算法的名字以发明者的名字命名:Ron Rivest, AdiShamir 和Leonard Adleman)
DES/3DES(Digital Signature Algorithm,数字签名)
国密算法
SM2/SM4(是由国家密码管理局编制的一种商用密码分组标准对称算法)
使用方法:
base64
1
2
3
4
5
6
7
8
|
public
static
byte
[] encode2Base64(
byte
[] bytes) {
byte
[] bts = Base64.encodeBase64(bytes);
return
bts;
}
public
static
byte
[] decode2Base64(String str) {
byte
[] bts = Base64.decodeBase64(str);
return
bts;
}
|
MD5
1
2
3
4
5
6
7
8
9
|
public
static
String md5(String str) {
try
{
MessageDigest digest = MessageDigest.getInstance(
"MD5"
);
return
new
String(digest.digest(str.getBytes()));
}
catch
(NoSuchAlgorithmException e) {
e.printStackTrace();
}
return
""
;
}
|
SHA-1
1
2
3
4
5
6
7
8
9
10
|
public
static
byte
[] sha1ToBytes(String str) {
try
{
MessageDigest digest = MessageDigest.getInstance(
"SHA-1"
);
byte
[] bts = digest.digest(str.getBytes());
return
bts;
}
catch
(Exception e) {
e.printStackTrace();
}
return
null
;
}
|
DES/3DES
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
|
public
static
byte
[] encryptMode(String keyStr,
byte
[] src) {
try
{
// 生成密钥
SecretKey deskey =
new
SecretKeySpec(keyStr.getBytes(),
"DESede"
);
// 加密
Cipher c1 = Cipher.getInstance(
"DESede"
);
c1.init(Cipher.ENCRYPT_MODE, deskey);
return
c1.doFinal(src);
}
catch
(java.security.NoSuchAlgorithmException e1) {
e1.printStackTrace();
}
catch
(javax.crypto.NoSuchPaddingException e2) {
e2.printStackTrace();
}
catch
(java.lang.Exception e3) {
e3.printStackTrace();
}
return
null
;
}
public
static
byte
[] decryptMode(String keyStr,
byte
[] src) {
try
{
SecretKey deskey =
new
SecretKeySpec(keyStr.getBytes(),
"DESede"
);
// 解密
Cipher c1 = Cipher.getInstance(
"DESede"
);
c1.init(Cipher.DECRYPT_MODE, deskey);
return
c1.doFinal(src);
}
catch
(java.security.NoSuchAlgorithmException e1) {
e1.printStackTrace();
}
catch
(javax.crypto.NoSuchPaddingException e2) {
e2.printStackTrace();
}
catch
(java.lang.Exception e3) {
e3.printStackTrace();
}
return
null
;
}
|
RSA
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
|
/**
* 初始化公密钥
*
* @return
* @throws Exception
*/
public
static
Map<String, Object> initKey()
throws
Exception {
KeyPairGenerator kpGenerator = KeyPairGenerator.getInstance(
"RSA"
);
kpGenerator.initialize(
2048
);
KeyPair keyPair = kpGenerator.generateKeyPair();
// 存储公钥
PublicKey publicKey = keyPair.getPublic();
// 存储密钥
PrivateKey privateKey = keyPair.getPrivate();
Map<String, Object> keyMap =
new
HashMap<String, Object>();
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return
keyMap;
}
/**
* 取出公钥
*
* @param keyMap
* @return
*/
public
static
String getPublicKey(Map<String, Object> keyMap) {
Key key = (Key) keyMap.get(
"RSAPublicKey"
);
return
encode2Base64(
new
String(key.getEncoded()));
}
/**
* 取出密钥
*
* @param keyMap
* @return
*/
public
static
String getPrivateKey(Map<String, Object> keyMap) {
Key key = (Key) keyMap.get(
"RSAPrivateKey"
);
return
encode2Base64(
new
String(key.getEncoded()));
}
/**
* 公钥加密
*
* @param data
* @param publicKey
* @return
* @throws Exception
*/
public
static
String encryptByPublicKey(String data, RSAPublicKey publicKey)
throws
Exception {
Cipher cipher = Cipher.getInstance(
"RSA"
);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// 模长
int
key_len = publicKey.getModulus().bitLength() /
8
;
// 加密数据长度 <= 模长-11
String[] datas = splitString(data, key_len -
11
);
String mi =
""
;
// 如果明文长度大于模长-11则要分组加密
for
(String s : datas) {
mi += bcd2Str(cipher.doFinal(s.getBytes()));
}
return
mi;
}
/**
* 私钥加密
*
* @param data
* @param privateKey
* @return
* @throws Exception
*/
public
static
String encryptByPrivateKey(String data,
RSAPrivateKey privateKey)
throws
Exception {
Cipher cipher = Cipher.getInstance(
"RSA"
);
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
// 模长
int
key_len = privateKey.getModulus().bitLength() /
8
;
// 加密数据长度 <= 模长-11
String[] datas = splitString(data, key_len -
11
);
String mi =
""
;
// 如果明文长度大于模长-11则要分组加密
for
(String s : datas) {
mi += bcd2Str(cipher.doFinal(s.getBytes()));
}
return
mi;
}
/**
* 私钥解密
*
* @param data
* @param privateKey
* @return
* @throws Exception
*/
public
static
String decryptByPrivateKey(String data,
RSAPrivateKey privateKey)
throws
Exception {
Cipher cipher = Cipher.getInstance(
"RSA"
);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
// 模长
int
key_len = privateKey.getModulus().bitLength() /
8
;
byte
[] bytes = data.getBytes();
byte
[] bcd = ASCII_To_BCD(bytes, bytes.length);
System.err.println(bcd.length);
// 如果密文长度大于模长则要分组解密
String ming =
""
;
byte
[][] arrays = splitArray(bcd, key_len);
for
(
byte
[] arr : arrays) {
ming +=
new
String(cipher.doFinal(arr));
}
return
ming;
}
/**
* ASCII码转BCD码
*
*/
public
static
byte
[] ASCII_To_BCD(
byte
[] ascii,
int
asc_len) {
byte
[] bcd =
new
byte
[asc_len /
2
];
int
j =
0
;
for
(
int
i =
0
; i < (asc_len +
1
) /
2
; i++) {
bcd[i] = asc_to_bcd(ascii[j++]);
bcd[i] = (
byte
) (((j >= asc_len) ?
0x00
: asc_to_bcd(ascii[j++])) + (bcd[i] <<
4
));
}
return
bcd;
}
public
static
byte
asc_to_bcd(
byte
asc) {
byte
bcd;
if
((asc >=
'0'
) && (asc <=
'9'
))
bcd = (
byte
) (asc -
'0'
);
else
if
((asc >=
'A'
) && (asc <=
'F'
))
bcd = (
byte
) (asc -
'A'
+
10
);
else
if
((asc >=
'a'
) && (asc <=
'f'
))
bcd = (
byte
) (asc -
'a'
+
10
);
else
bcd = (
byte
) (asc -
48
);
return
bcd;
}
/**
* BCD转字符串
*/
public
static
String bcd2Str(
byte
[] bytes) {
char
temp[] =
new
char
[bytes.length *
2
], val;
for
(
int
i =
0
; i < bytes.length; i++) {
val = (
char
) (((bytes[i] &
0xf0
) >>
4
) &
0x0f
);
temp[i *
2
] = (
char
) (val >
9
? val +
'A'
-
10
: val +
'0'
);
val = (
char
) (bytes[i] &
0x0f
);
temp[i *
2
+
1
] = (
char
) (val >
9
? val +
'A'
-
10
: val +
'0'
);
}
return
new
String(temp);
}
/**
* 拆分字符串
*/
public
static
String[] splitString(String string,
int
len) {
int
x = string.length() / len;
int
y = string.length() % len;
int
z =
0
;
if
(y !=
0
) {
z =
1
;
}
String[] strings =
new
String[x + z];
String str =
""
;
for
(
int
i =
0
; i < x + z; i++) {
if
(i == x + z -
1
&& y !=
0
) {
str = string.substring(i * len, i * len + y);
}
else
{
str = string.substring(i * len, i * len + len);
}
strings[i] = str;
}
return
strings;
}
/**
* 拆分数组
*/
public
static
byte
[][] splitArray(
byte
[] data,
int
len) {
int
x = data.length / len;
int
y = data.length % len;
int
z =
0
;
if
(y !=
0
) {
z =
1
;
}
byte
[][] arrays =
new
byte
[x + z][];
byte
[] arr;
for
(
int
i =
0
; i < x + z; i++) {
arr =
new
byte
[len];
if
(i == x + z -
1
&& y !=
0
) {
System.arraycopy(data, i * len, arr,
0
, y);
}
else
{
System.arraycopy(data, i * len, arr,
0
, len);
}
arrays[i] = arr;
}
return
arrays;
}
|