Java加密总结：常见哈希算法总结、对称式加密与非对称式加密的对比

---

前言

随着人工智能的不断发展，密码学这门技术也越来越重要，很多人都在加密算法的探索中，而我们本次文章就介绍下，常见的各种算法。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、加密是什么？

加密是在日常生活中，都可接触到的。比如对电脑设置密码，各种APP的登陆密码都是加密的一种，而今天要说的就是解密算法中比较常用几种算法，哈希算法，对称加密，非对称加密。

一、哈希算法

1.什么是哈希算法？

哈希算法又称为“摘要算法”，它的作用是任意一组输入数据进行计算。得到一个固定长度的输出摘要。哈希算法的目的是验证原始数据是否被篡改。

2、常见的哈希算法有那些？

常见的的哈希算法有:MD5 SHA-1; SHA-256; SHA-512;

算法	输出长度(字节)
MD5	16
SHA-1	20
SHA-256	32
SHA-512	64

3、哈希碰撞

哈希碰撞就是指两个不同的输入得到相同的输出：

"AaAaAa".hashCode(); // 0x7460e8c0
"BBAaBB".hashCode(); // 0x7460e8c0

"通话".hashCode(); // 0x11ff03
"重地".hashCode(); // 0x11ff03

这个就是所谓的哈希碰撞，可是哈希碰撞又事无法避免的，因为输入数据的长度是不固定的，而输出结果又是固定长度的，所以一定会有重复的。
但是好的哈希算法可以将这种概率降到最低。同时，好的哈希算法不能猜测出输出。

4、哈希算法的用处

（1）、检验下载文件

我们知道哈希算法，输出的结果固定、，输出的长度固定。所以在下载文件时可以与官方提供的哈希值比较，来检验文件是否被篡改。

（2）、存储密码

哈希算法的另一个用处就是储存用户的口令。如果直接储存用户的口令到数据库这样有很大的风险。所以大多数会采用哈希算法来计算出哈希值，将用户的口令计算得到的哈希值储存在数据库。
具体代码如下：以MD5为例

ublic class demo02 {
	public static void main(String[] args) {
		try {
			String world = "我本将心向明月";
			// 获取MD5工具对象
			MessageDigest msd = MessageDigest.getInstance("MD5");
			// 更新原始元素
			msd.update(world.getBytes());
			byte[] by = msd.digest();
			StringBuilder buff = new StringBuilder();
			for (byte b : by) {
				buff.append(String.format("%02x", b));
			}
			System.out.println("字符长度"+buff.length());
			System.out.println("哈希值"+buff);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
	}
}

输出结果为：

字符长度32
哈希值e9c89b73f43977b00362911348669e3d

而SHA-1与MD5基本相同，只是将算法名改为：SHA-1。

二、对称加密

1、什么是对称加密算法

对称算法就是传统的用一个密码进行加密和解密。

2、常见的对称加密算法

算法	工作模式
DES	ECB/CBC
AEC	ECB/CBC
AES	ECB/CBC

具体代码如下：

package pro;

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class demo02 {
	public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
			IllegalBlockSizeException, BadPaddingException {
		// 原文
		String message = "你好";
		System.out.println(message);
		
		// 128位密钥 = 16字节
		byte[] key = "1234567890abcdef".getBytes();
		byte[] data = message.getBytes();
		
		// 加密
		byte[] encrypte = encrypt(key, data);
		System.out.println("加密:" + Base64.getEncoder().encodeToString(encrypte));

		// 解密
		byte[] decrypte = decrypt(key, encrypte);
		System.out.println("解密:" + new String(decrypte));

	}

	// 加密
	public static byte[] encrypt(byte[] key, byte[] input) throws NoSuchAlgorithmException, NoSuchPaddingException,
			InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		// 创建密码对象,需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		
		// 根据key的字节内容,恢复密钥对象
		SecretKey keys = new SecretKeySpec(key, "AES");
		
		// 初始化密钥:设置密钥加密模式
		cipher.init(Cipher.ENCRYPT_MODE, keys);
		
		// 根据原始内容,进行加密
		return cipher.doFinal(input);
	}

	// 解密
	public static byte[] decrypt(byte[] key, byte[] input) throws NoSuchAlgorithmException, NoSuchPaddingException,
			InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		// 创建密码对象,需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		
		// 根据key的字节内容,恢复密钥对象
		SecretKey keys = new SecretKeySpec(key, "AES");
		
		// 初始化密钥:设置密钥加密模式
		cipher.init(Cipher.DECRYPT_MODE, keys);
		
		// 根据原始内容,进行加密
		return cipher.doFinal(input);
	}
}

结果如下：

你好
加密:mh6wgMxmUzmdvXM3OVvmwg==
解密:你好

三、非对称加密算法

1、什么是非对称算法

加密和解密使用不同的密钥，只有同一个公钥和密钥才能正常的解密和加密。

2、常见的对称加密算法

RSA算法是经典的非对称加密算法。

具体代码如下：

```java
package pro;

import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;

import javax.crypto.Cipher;

// RSA
public class Main05 {
	public static void main(String[] args) throws Exception {
		// 明文:
		byte[] plain = "Hello, encrypt use RSA".getBytes("UTF-8");

		// 创建公钥／私钥对:
		Human alice = new Human("Alice");

		// 用Alice的公钥加密:
		// 获取Alice的公钥，并输出
		byte[] pk = alice.getPublicKey();
		System.out.println(String.format("public key(公钥): %x", new BigInteger(1, pk)));

		// 使用公钥加密
		byte[] encrypted = alice.encrypt(plain);
		System.out.println(String.format("encrypted: %x", new BigInteger(1, encrypted)));

		// 用Alice的私钥解密:
		// 获取Alice的私钥，并输出
		byte[] sk = alice.getPrivateKey();
		System.out.println(String.format("private key: %x", new BigInteger(1, sk)));

		// 使用私钥解密
		byte[] decrypted = alice.decrypt(encrypted);
		System.out.println(new String(decrypted, "UTF-8"));
	}
}

// 用户类
class Human {
	// 姓名
	String name;

	// 私钥:
	PrivateKey sk;

	// 公钥:
	PublicKey pk;

	// 构造方法
	public Human(String name) throws GeneralSecurityException {
		// 初始化姓名
		this.name = name;

		// 生成公钥／私钥对:
		KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA");
		kpGen.initialize(1024);
		KeyPair kp = kpGen.generateKeyPair();

		this.sk = kp.getPrivate();
		this.pk = kp.getPublic();
	}

	// 把私钥导出为字节
	public byte[] getPrivateKey() {
		return this.sk.getEncoded();
	}

	// 把公钥导出为字节
	public byte[] getPublicKey() {
		return this.pk.getEncoded();
	}

	// 用公钥加密:
	public byte[] encrypt(byte[] message) throws GeneralSecurityException {
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(Cipher.ENCRYPT_MODE, this.pk); // 使用公钥进行初始化
		return cipher.doFinal(message);
	}

	// 用私钥解密:
	public byte[] decrypt(byte[] input) throws GeneralSecurityException {
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(Cipher.DECRYPT_MODE, this.sk); // 使用私钥进行初始化
		return cipher.doFinal(input);
	}
}

总结

哈希算法可验证文件是否被才篡改，储存用户的口令
用哈希算法储存口令要考虑彩虹表攻击
对称算法的使用要指定，算法名称，工作模式和填充模式