java中常用的对称加密与非对称加密

最新推荐文章于 2023-07-02 10:56:52 发布
最新推荐文章于 2023-07-02 10:56:52 发布
阅读量137 收藏
点赞数
文章标签： 加密

特殊说明

所有的算法都有main方法，可直接运行

对称机密

同一个秘钥

DES

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

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

/**

  • 对称加密 【DES】

  • @author it
    */
    public class DESUtil {
    private static final String KEY_ALGORITHM = “DES”;
    private static final String DEFAULT_CIPHER_ALGORITHM = “DES/ECB/PKCS5Padding”;// 默认的加密算法

    /**

    • DES 加密操作

    • @return 返回Base64转码后的加密数据
      */
      public static String encrypt(String content, String key) {
      try {
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

       byte[] byteContent = content.getBytes("utf-8");

 cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器

 byte[] result = cipher.doFinal(byteContent);// 加密

 return Base64.getEncoder().encodeToString(result);// 通过Base64转码返回

      } catch (Exception ex) {
      Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    /**

    • DES 解密操作
      */
      public static String decrypt(String content, String key) {

      try {
      // 实例化
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

       // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));

 // 执行操作
 byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));

 return new String(result, "utf-8");

      } catch (Exception ex) {
      Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    /**

    • 生成加密秘钥

    • @return
      */
      private static SecretKeySpec getSecretKey(final String key) {
      // 返回生成指定算法密钥生成器的 KeyGenerator 对象
      KeyGenerator kg = null;

      try {
      kg = KeyGenerator.getInstance(KEY_ALGORITHM);

       // DES 要求密钥长度为 56
 kg.init(56, new SecureRandom(key.getBytes()));

 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();

 return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DES专用密钥

      } catch (NoSuchAlgorithmException ex) {
      Logger.getLogger(DESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    public static void main(String[] args) {
    String content = “hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的”;
    String key = “sde@5f98H*^hsff%dfs$r344&df8543*er”;
    System.out.println(“原始内容:” + content);
    String s1 = DESUtil.encrypt(content, key);
    System.out.println(“加密后:” + s1);
    System.out.println(“解密后:” + DESUtil.decrypt(s1, key));
    }
    }

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
3DES

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

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

/**

  • 对称加密 【3DES】

  • @author it
    */
    public class TripDESUtil {
    private static final String KEY_ALGORITHM = “DESede”;
    private static final String DEFAULT_CIPHER_ALGORITHM = “DESede/ECB/PKCS5Padding”;// 默认的加密算法

    /**

    • DESede 加密操作

    • @return 返回Base64转码后的加密数据
      */
      public static String encrypt(String content, String key) {
      try {
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

       byte[] byteContent = content.getBytes("utf-8");

 cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器

 byte[] result = cipher.doFinal(byteContent);// 加密

 return Base64.getEncoder().encodeToString(result);// 通过Base64转码返回

      } catch (Exception ex) {
      Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    /**

    • DESede 解密操作
      */
      public static String decrypt(String content, String key) {

      try {
      // 实例化
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

       // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));

 // 执行操作
 byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));

 return new String(result, "utf-8");

      } catch (Exception ex) {
      Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    /**

    • 生成加密秘钥
      */
      private static SecretKeySpec getSecretKey(final String key) {
      // 返回生成指定算法密钥生成器的 KeyGenerator 对象
      KeyGenerator kg = null;

      try {
      kg = KeyGenerator.getInstance(KEY_ALGORITHM);

       // DESede
 kg.init(new SecureRandom(key.getBytes()));

 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();

 return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为DESede专用密钥

      } catch (NoSuchAlgorithmException ex) {
      Logger.getLogger(TripDESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    public static void main(String[] args) {
    String content = “hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的”;
    String key = “sde@5f98H*^hsff%dfs$r344&df8543*er”;
    System.out.println(“原始内容:” + content);
    String s1 = TripDESUtil.encrypt(content, key);
    System.out.println(“加密后:” + s1);
    System.out.println(“解密后:” + TripDESUtil.decrypt(s1, key));
    }
    }

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
AES

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;
import java.util.logging.Level;
import java.util.logging.Logger;

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

/**

  • 对称加密 【AES】

  • @author it
    */
    public class AESUtil {
    private static final String KEY_ALGORITHM = “AES”;
    private static final String DEFAULT_CIPHER_ALGORITHM = “AES/ECB/PKCS5Padding”;// 默认的加密算法

    /**

    • AES 加密操作

    • @return 返回Base64转码后的加密数据
      */
      public static String encrypt(String content, String key) {
      try {
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

       byte[] byteContent = content.getBytes("utf-8");

 cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器

 byte[] result = cipher.doFinal(byteContent);// 加密

 return Base64.getEncoder().encodeToString(result);// 通过Base64转码返回

      } catch (Exception ex) {
      Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    /**

    • AES 解密操作
      */
      public static String decrypt(String content, String key) {

      try {
      // 实例化
      Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

       // 使用密钥初始化，设置为解密模式
 cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));

 // 执行操作
 byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));

 return new String(result, "utf-8");

      } catch (Exception ex) {
      Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    /**

    • 生成加密秘钥
      */
      private static SecretKeySpec getSecretKey(final String key) {
      // 返回生成指定算法密钥生成器的 KeyGenerator 对象
      KeyGenerator kg = null;

      try {
      kg = KeyGenerator.getInstance(KEY_ALGORITHM);

       // AES 要求密钥长度为 128
 kg.init(128, new SecureRandom(key.getBytes()));

 // 生成一个密钥
 SecretKey secretKey = kg.generateKey();

 return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥

      } catch (NoSuchAlgorithmException ex) {
      Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
      }

      return null;
      }

    public static void main(String[] args) {
    String content = “hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的”;
    String key = “sde@5f98H*^hsff%dfs$r344&df8543*er”;
    System.out.println(“原始内容:” + content);
    String s1 = AESUtil.encrypt(content, key);
    System.out.println(“加密后:” + s1);
    System.out.println(“解密后:” + AESUtil.decrypt(s1, key));
    }
    }

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
非对称机密

RSA

import java.io.ByteArrayOutputStream;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

/**

  • RSA公钥/私钥/签名工具包

  • 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）

  • 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式
  • 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，
  • 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全

*/
public class RSAUtils {

/**
 * 加密算法RSA
 */
public static final String KEY_ALGORITHM = "RSA";

/**
 * 签名算法
 */
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

/**
 * 获取公钥的key
 */
private static final String PUBLIC_KEY = "RSAPublicKey";

/**
 * 获取私钥的key
 */
private static final String PRIVATE_KEY = "RSAPrivateKey";

/**
 * RSA最大加密明文大小
 */
private static final int MAX_ENCRYPT_BLOCK = 117;

/**
 * RSA最大解密密文大小
 */
private static final int MAX_DECRYPT_BLOCK = 128;

/**
 * <p>
 * 用私钥对信息生成数字签名
 * </p>
 *
 * @param data
 *            已加密数据
 * @param privateKey
 *            私钥(BASE64编码)
 *
 * @return
 * @throws Exception
 */
public static String sign(byte[] data, String privateKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(privateKey);
	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
	Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
	signature.initSign(privateK);
	signature.update(data);
	return Base64Utils.encode(signature.sign());
}

/**
 * <p>
 * 校验数字签名
 * </p>
 *
 * @param data
 *            已加密数据
 * @param publicKey
 *            公钥(BASE64编码)
 * @param sign
 *            数字签名
 *
 * @return
 * @throws Exception
 *
 */
public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
	byte[] keyBytes = Base64Utils.decode(publicKey);
	X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	PublicKey publicK = keyFactory.generatePublic(keySpec);
	Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
	signature.initVerify(publicK);
	signature.update(data);
	return signature.verify(Base64Utils.decode(sign));
}

/**
 * <P>
 * 私钥解密
 * </p>
 *
 * @param encryptedData
 *            已加密数据
 * @param privateKey
 *            私钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(privateKey);
	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.DECRYPT_MODE, privateK);
	int inputLen = encryptedData.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段解密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
			cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_DECRYPT_BLOCK;
	}
	byte[] decryptedData = out.toByteArray();
	out.close();
	return decryptedData;
}

/**
 * <p>
 * 公钥解密
 * </p>
 *
 * @param encryptedData
 *            已加密数据
 * @param publicKey
 *            公钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(publicKey);
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key publicK = keyFactory.generatePublic(x509KeySpec);
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.DECRYPT_MODE, publicK);
	int inputLen = encryptedData.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段解密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
			cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_DECRYPT_BLOCK;
	}
	byte[] decryptedData = out.toByteArray();
	out.close();
	return decryptedData;
}

/**
 * <p>
 * 公钥加密
 * </p>
 *
 * @param data
 *            源数据
 * @param publicKey
 *            公钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(publicKey);
	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key publicK = keyFactory.generatePublic(x509KeySpec);
	// 对数据加密
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.ENCRYPT_MODE, publicK);
	int inputLen = data.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段加密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
			cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(data, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_ENCRYPT_BLOCK;
	}
	byte[] encryptedData = out.toByteArray();
	out.close();
	return encryptedData;
}

/**
 * <p>
 * 私钥加密
 * </p>
 *
 * @param data
 *            源数据
 * @param privateKey
 *            私钥(BASE64编码)
 * @return
 * @throws Exception
 */
public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
	byte[] keyBytes = Base64Utils.decode(privateKey);
	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
	Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
	cipher.init(Cipher.ENCRYPT_MODE, privateK);
	int inputLen = data.length;
	ByteArrayOutputStream out = new ByteArrayOutputStream();
	int offSet = 0;
	byte[] cache;
	int i = 0;
	// 对数据分段加密
	while (inputLen - offSet > 0) {
		if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
			cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
		} else {
			cache = cipher.doFinal(data, offSet, inputLen - offSet);
		}
		out.write(cache, 0, cache.length);
		i++;
		offSet = i * MAX_ENCRYPT_BLOCK;
	}
	byte[] encryptedData = out.toByteArray();
	out.close();
	return encryptedData;
}

/**
 * <p>
 * 生成密钥对(公钥和私钥)
 * </p>
 *
 * @return
 * @throws Exception
 */
public static Map<String, Object> genKeyPair() throws Exception {
	KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
	keyPairGen.initialize(1024);
	KeyPair keyPair = keyPairGen.generateKeyPair();
	RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
	RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
	Map<String, Object> keyMap = new HashMap<String, Object>(2);
	keyMap.put(PUBLIC_KEY, publicKey);
	keyMap.put(PRIVATE_KEY, privateKey);
	return keyMap;
}

/**
 * <p>
 * 获取私钥
 * </p>
 *
 * @param keyMap
 *            密钥对
 * @return
 * @throws Exception
 */
public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
	Key key = (Key) keyMap.get(PRIVATE_KEY);
	return Base64Utils.encode(key.getEncoded());
}

/**
 * <p>
 * 获取公钥
 * </p>
 *
 * @param keyMap
 *            密钥对
 * @return
 * @throws Exception
 */
public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
	Key key = (Key) keyMap.get(PUBLIC_KEY);
	return Base64Utils.encode(key.getEncoded());
}

public static void main(String[] args) throws Exception {
	Map<String, Object> keyPairs = RSAUtils.genKeyPair();
	String privateKey = RSAUtils.getPrivateKey(keyPairs);
	String publicKey = RSAUtils.getPublicKey(keyPairs);

	System.out.println("私钥：" + privateKey);
	System.out.println("公钥：" + publicKey);

	// 公钥加密，私钥解密
	String content = "hello,您好，李四，我喜欢你，这个内容加密了，别人不知道的";
	byte[] encryptedData = RSAUtils.encryptByPublicKey(content.getBytes(Charset.defaultCharset()), publicKey);
	byte[] decryptedData = RSAUtils.decryptByPrivateKey(encryptedData, privateKey);
	System.out.println(new String(decryptedData));

	// 数字签名验证
	// 私钥签名，生产一个key
	String sign = RSAUtils.sign(encryptedData, privateKey);
	// 公钥验证
	boolean verify = RSAUtils.verify(encryptedData, publicKey, sign);
	System.out.println("内容是否安全：" + verify);

	// 私钥加密，公钥解密
	content = "滚你妈的";
	byte[] encryptedData2 = RSAUtils.encryptByPrivateKey(content.getBytes(Charset.defaultCharset()), privateKey);
	byte[] decryptedData2 = RSAUtils.decryptByPublicKey(encryptedData2, publicKey);
	System.out.println(new String(decryptedData2));
}

}
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
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
附加工具类base64

import java.util.Base64;

public class Base64Utils {

/**
 * <p>
 * BASE64字符串解码为二进制数据
 * </p>
 *
 * @param base64
 * @return
 * @throws Exception
 */
public static byte[] decode(String base64) throws Exception {
    return Base64.getDecoder().decode(base64.getBytes());
}

/**
 * <p>
 * 二进制数据编码为BASE64字符串
 * </p>
 *
 * @param bytes
 * @return
 * @throws Exception
 */
public static String encode(byte[] bytes) throws Exception {
	return new String(Base64.getEncoder().encode(bytes));
}

}

作者：dengjili
来源：CSDN
原文：https://blog.csdn.net/dengjili/article/details/85862201
版权声明：本文为博主原创文章，转载请附上博文链接！

weixin_43643054
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 对称加密 教程_对称加密算法 之 PBE
weixin_35327421的博客
02-24 371
PBE算法 结合了消息摘要算法 和 对称加密算法 的优点PBE(Password Based Encryption) 基于口令加密特点：1、对已有的算法的包装2、有 JDK、BC 等实现方式3、增加盐口令4、PBE是一个综合性的对称加密算法，常用的PBEWithMD5AndDES 等。算法密钥长度默认工作模式填充方式实现PBEWithMD5AndDES5656CBCPKCS5PaddingJDKP...
java desede 工作模式_Java 加密解密之对称加密算法DESede
weixin_35907598的博客
02-13 1115
JAVA加密解密系列Java 加密解密之对称加密算法DESedeDESede即三重 DES加密算法，也被称为3DES或者Triple DES。使用三(或两)个不同的密钥对数据块进行三次(或两次)DES加密(加密一次要比进行普通加密的三次要快)。三重DES的强度大约和112- bit的密钥强度相当。通过迭代次数的提高了安全性，但同时也造成了加密效率低的问题。正因DESede算法效率问题，AES算法...
Java 加密算法：对称加密和非对称加密总结
u013558123的博客
06-21 2317
RSA 非对称加密， AES 对称加密
java对称加密和非对称加密（PBE、DH、RSA）
cliper9768的博客
10-18 698
1. 什么是对称式加密和非对称式加密 对称式加密：解密方式是加密方式的逆运算，即加密和解密使用的是同一个密钥（初等加密算法）。 非对称式加密：加密和解密需要两个密钥进行，这两个密钥是公钥和私钥（高等加密算法）。 2. 对称式加密和非对称式加密的主要实现方式 对称式加密主要实现方式： 1） DES（Data Encryption Standard）：安全性较差，一般不建议使...
Java加密与安全 —— 对称式加密与非对称式加密的对比
weixin_45939128的博客
07-22 1172
Java加密与安全 —— 对称式加密与非对称式加密的对比
java 加密 —— 对称加密、非对称加密、消息摘要
猎人在吃肉
06-20 2212
文章目录1.1 密码学基本概念1.1.1 古典密码学1.1.2 近代密码学1.1.3 现代密码学1.1.4 如何设置密码才安全1.2 ASCII编码1.3 恺撒加密1.3.1 中国古代加密1.3.2 外国加密1.3.3 凯撒位移加密1.3.4 凯撒加密和解密1.4 频度分析法破解恺撒加密1.5 Byte和bit1.5.1 获取字符串byte1.5.2 byte对应bit1.5.3 中文对应的字节1.5.4 英文对应的字节1.6 常见加密方式1.6.1 对称加密的概念1.6.2 DES 加密解密1）DES 加
Java对称与非对称加密解密(AES与RSA)
最新发布
s_sos0的博客
07-02 937
Java对称 & 非对称加密解密(AES与RSA)
非对称加密JAVA实现
08-06
非对称加密JAVA实现，实现对超长内容进行加密
java实现非对称加密
12-26
在 Java 中，可以使用 RSA 算法实现非对称加密。 RSA 算法是最常用的非对称加密算法之一。它的安全性取决于密钥的长度和安全性。 Java 中的 RSA 加密可以分为以下步骤： 1. 生成公钥和私钥：使用 KeyPairGenerator...
java 非对称加密算法RSA实现详解
08-25
Java 非对称加密算法RSA实现详解是 Java 语言中的一种常用加密算法，主要用于保护数据的安全性。 RSA 算法是一种基于大数分解的加密算法，它的安全性取决于大数分解的难度。在 Java 中，RSA 加密算法可以用来实现...
Java对称和非对称加密的Java文件
09-26
支持Java文件遇见的敏感字段的加密 包括对称和非对称加密
Java非对称加密源码实例
06-13
Java非对称加密源码实例
Rsa非对称加密Java实现和举例
06-09
* RAS用来加密机密数据:密码/转账资金等等，数据不能呢个太大，否则会非常耗费资源. * 一般随机生成公钥和私钥，用户只需要保存好对应的密钥对，不用关心密码到底是什么. * RAS非对唱加密Java实现： * 1．采用分组加密的方式，明文可以比较长，理论上无线长，但是太耗费时间 * 2. 不采用分组加密，直接整个元数据加密的话，每次最多加 117 bytes,
C#对称加密与非对称加密实例
09-04
C#中，非对称加密的常用算法有RSA（Rivest-Shamir-Adleman）和DSA（Digital Signature Algorithm）。RSA是目前应用最广泛的公钥加密算法，提供了加密和数字签名功能。在.NET中，`RSACryptoServiceProvider`类用于...
Java非对称加密源码实例.zip
08-27
这个"Java非对称加密源码实例.zip"压缩包很可能是包含了一些示例代码，帮助开发者理解和使用Java中的非对称加密功能。 非对称加密的核心概念是公钥和私钥的配对。公钥是公开的，任何人都可以获取，用于加密数据；而...
浅谈对称加密与非对称加密
筱葭的博客
03-06 583
1、对称加密（Symmetric Cryptography） 对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）,这种方法在密码学中叫做对称加密算法。对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。 对称加密通常使用的是相对较小的密钥，一般小于256 bit。因为密钥越大，加密
Java加密：对称式加密与非对称式加密的对比
qq_46853052的博客
07-21 655
对称式加密与非对称式加密的对比
Java安全之对称加密、非对称加密、数字签名
热门推荐
文忠专栏
10-17 1万+
Java中加密分为两种方式一个是对称加密，另一个是非对称加密。对称加密是因为加密和解密的钥匙相同，而非对称加密是加密和解密的钥匙不同。 对称加密与非对称加密的区别： 对称加密称为密钥加密，速度快，但加密和解密的钥匙必须相同，只有通信双方才能知道密钥。 非对称加密称为公钥加密，算法更加复杂，速度慢，加密和解密钥匙不相同，任何人都可以知道公钥，只有一个人持有私钥可以解密。 对称加密解密：
Java与Android安全加密实战：对称加密、非对称加密与HTTPS
"Java和Android安全加密，涵盖了对称加密、非对称加密、数字摘要、数字签名、数字证书和Https编程的相关知识。" 在Java和Android开发中，安全加密是至关重要的，它确保了数据在传输过程中的隐私性和完整性。本专题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值