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

哈希算法:哈希算法(Hash)又称摘要算法(Digest),

作用：对任意一组输入数据进行计算，得到一个固定长度的输出摘要。

目的：为了验证原始数据是否被篡改。

特点：相同的输入一定得到相同的输出；不同的输入大概率得到不同的输出。

Java字符串的hashCode()就是一个哈希算法，它的输入是任意字符串，输出是固定的4字节 int整数:

"hello".hashCode(); // 0x5e918d2
"hello, java".hashCode(); // 0x7a9d88e8
"hello, bob".hashCode(); // 0xa0dbae2f

两个相同的字符串永远会计算出相司的hashcode 。否则基于hashcode 定位的 HashMap就无法正常工作。这也是为什么当我们自定义一个 class时，覆写e quals()方法时我们必须正确覆写hashcode())方法。

然而这样也不能保证所有的字符串的哈希值都不相同，当相同时就会发生哈希碰撞。

哈希碰撞：两个不同的输入得到相同输出。例如通话和重地。

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

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

碰撞能不能避免?答案是不能。碰撞是一定会出现的，因为输出的字节长度是固定的， string 的 hashcode()输出是 4 字节整数，最多只有 4294967296 种输出，但输入的数据长度是不固定的，有无数种输入。所以，哈希算法是把一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞。

碰撞不可怕，我们担心的不是碰撞，而是碰撞的概率，因为碰撞概率的高低关系到哈希算法的安全性。一个安全的哈希算法必须满足：

碰撞概率低;·不能猜测输出。
不能猜测输出是指:输入的任意一个 bit 的变化会造成输出完全不同，这样就很难从输出反推输入(只能依靠暴力穷举)。

常见哈希算法：根据碰撞概率，哈希算法的输出长度越长，就越难产生碰撞，也就越安全。

算法	输出长度(位	输出长度(字节)
MD5	128 bits	16 bytes
SHA-1	160 bits	20 bytes
RipeMD-160	160 bits	20 bytes
SHA-256	256 bits	32 bytes
SHA-512	512 bits	64 bytes

Java标准库提供了常用的哈希算法，并且有一套统一的接口。我们以 MD5算法为例，看看如何对输入计算哈希:

import java.security.MessageDigest;

public class main {
	public static void main(String[] args)  {
		// 创建一个MessageDigest实例:
        MessageDigest md = MessageDigest.getInstance("MD5");
       
        // 反复调用update输入数据:
        md.update("Hello".getBytes("UTF-8"));
        md.update("World".getBytes("UTF-8"));
        
        // 16 bytes: 68e109f0f40ca72a15e05cc22786f8e6
        byte[] results = md.digest(); 

        StringBuilder sb = new StringBuilder();
        for(byte bite : results) {
        	sb.append(String.format("%02x", bite));
        }
        
        System.out.println(sb.toString());
	}
}

使用MessageDigest时，我们首先根据哈希算法获取一个 MessageDigest实例，然后，反复调用update(byte[])输入数据。当输入结束后，调用digest()方法获得byte[]数组表示的摘要，最后，把它转换为十六进制的字符串。

哈希算法的用途：校验下载文件；存储用户密码

使用哈希口令时，还要注意防止彩虹表攻击。什么是彩虹表呢?上面讲到了，如果只拿到MD5，从MD5反推明文口令，只能使用暴力穷举的方法。然而黑客并不笨，暴力穷举会消耗大量的算力和时间。但是，如果有一个预先计算好的常用口令和它们的MD5的对照表，这个表就是彩虹表。如果用户使用了常用口令，黑客从MD5一下就能反查到原始口令。

当然，我们也可以采取特殊措施来抵御彩虹表攻击:对每个口令额外添加随机数，这个方法称之为加盐(salt)

try {
			String password = "myjsy";
			String salt = UUID.randomUUID().toString().substring(0, 5);//加盐
			
			System.out.println(salt);
			MessageDigest md5 = MessageDigest.getInstance("MD5");
			md5.update(password.getBytes());
			md5.update(salt.getBytes());
			byte[] resultArray = md5.digest();
			System.out.println(Arrays.toString(resultArray));
			System.out.println(resultArray.length);
			StringBuilder result = new StringBuilder();
			for (byte b : resultArray) {
				result.append(String.format("%02x", b));
			}
			System.out.println(result);
			System.out.println(result.length());
			System.out.println("..................");
			//获取SHA-1算法的工具对象
			MessageDigest digest = MessageDigest.getInstance("SHA-1");
			digest.update(password.getBytes());
			digest.update(salt.getBytes());
			byte[] buff = digest.digest();
			System.out.println(Arrays.toString(buff));
			System.out.println(buff.length);
			StringBuilder sb = new StringBuilder();
			for (byte num : buff) {
				sb.append(String.format("%02x", num));
			}
			System.out.println(sb);
			System.out.println(sb.length());
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

SHA-1：
SHA-1也是一种哈希算法，它的输出是160 bits，即20字节。SHA-1是由美国国家安全局开发的，SHA算法实际上是一个系列，包括SHA-8(已废弃)、SHA-1、SHA-256、SHA-512等。
在Java中使用SHA-1，和MD5完全一样，只需要把算法名称改为"SHA-1":

//获取SHA-1算法的工具对象
            MessageDigest digest = MessageDigest.getInstance("SHA-1");
            digest.update(password.getBytes());
            digest.update(salt.getBytes());
            byte[] buff = digest.digest();
            System.out.println(Arrays.toString(buff));
            System.out.println(buff.length);
            StringBuilder sb = new StringBuilder();
            for (byte num : buff) {
                sb.append(String.format("%02x", num));
            }

对称式加密：

对称加密算法就是传统的用一个密码进行加密和解密。例如，我们常用的 WinZIP 和WinRAR对压缩包的加密和解密，就是使用对称加密算法。

从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文:
secret = encrypt(key,message);
而解密则相反，它接收密码和密文，然后输出明文:
plain = decrypt(key,secret);

在软件开发中，常用的对称加密算法有:

算法	密钥长度	工作模式	填充模式
DES	56/64	ECB/CBC/PCBC/CTR/..	NoPadding/PKCS5Padding/..
AES	128/192/256	ECB/CBC/PCBC/CTR/	NoPadding/PKCS5Padding/PKCS7Padding/...
IDEA	128	ECB	PKCS5Padding/PKCS7Padding/..

密钥长度直接决定加密强度，而工作模式和填充模式可以看成是对称加密算法的参数和格式选择。Java标准库提供的算法实现并不包括所有的工作模式和所有填充模式，但是通常我们只需要挑选常用的使用就可以了。
最后注意， DES 算法由于密钥过短，可以在短时间内被暴力破解，所以现在已经不安全了。

使用AES加密
AES 算法是目前应用最广泛的加密算法。比较常见的工作模式是ECB 和CBC
ECB模式加密和解密：

import java.security.*;
import java.util.Base64;

import javax.crypto.*;
import javax.crypto.spec.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // 原文:
        String message = "Hello, world!";
        System.out.println("Message(原始信息): " + message);
        
        // 128位密钥 = 16 bytes Key:
        byte[] key = "1234567890abcdef".getBytes();
        
        // 加密:
        byte[] data = message.getBytes();
        byte[] encrypted = encrypt(key, data);
        System.out.println("Encrypted(加密内容): " + 
        					Base64.getEncoder().encodeToString(encrypted));
        
        // 解密:
        byte[] decrypted = decrypt(key, encrypted);
        System.out.println("Decrypted(解密内容): " + new String(decrypted));
    }

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

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

Java标准库提供的对称加密接口非常简单，使用时按以下步骤编写代码:
使用AES
1.根据算法名称/工作模式/填充模式获取 Cipher 实例;
2.根据算法名称初始化一个 SecretKey实例，密钥必须是指定长度;
3.使用 SerectKey初始化 Cipher 实例，并设置加密或解密模式;
4.传入明文或密文，获得密文或明文。

CBC模式
ECB模式是最简单的AES加密模式，它只需要一个固定长度的密钥，固定的明文会生成固定的密文，这种一对一的加密方式会导致安全性降低，更好的方式是通过CBC模式，它需要一个随机数作为IV参数，这样对于同一份明文，每次生成的密文都不同:

package com.apesource.demo04;

import java.security.*;
import java.util.Base64;

import javax.crypto.*;
import javax.crypto.spec.*;

public class Main {
	public static void main(String[] args) throws Exception {
        // 原文:
        String message = "Hello, world!";
        System.out.println("Message(原始信息): " + message);
        
        // 256位密钥 = 32 bytes Key:
        byte[] key = "1234567890abcdef1234567890abcdef".getBytes();
        
        // 加密:
        byte[] data = message.getBytes();
        byte[] encrypted = encrypt(key, data);
        System.out.println("Encrypted(加密内容): " + 
				Base64.getEncoder().encodeToString(encrypted));
        
        // 解密:
        byte[] decrypted = decrypt(key, encrypted);
        System.out.println("Decrypted(解密内容): " + new String(decrypted));
    }

    // 加密:
    public static byte[] encrypt(byte[] key, byte[] input) throws GeneralSecurityException {
        // 设置算法/工作模式CBC/填充
    	Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    	
    	// 恢复秘钥对象
        SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
        
        // CBC模式需要生成一个16 bytes的initialization vector:
        SecureRandom sr = SecureRandom.getInstanceStrong();
        byte[] iv = sr.generateSeed(16); // 生成16个字节的随机数
        System.out.println(Arrays.toString(iv));
        IvParameterSpec ivps = new IvParameterSpec(iv); // 随机数封装成IvParameterSpec参数对象
        
        // 初始化秘钥:操作模式、秘钥、IV参数
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivps);
        
        // 加密
        byte[] data = cipher.doFinal(input);
        
        // IV不需要保密，把IV和密文一起返回:
        return join(iv, data);
    }

    // 解密:
    public static byte[] decrypt(byte[] key, byte[] input) throws GeneralSecurityException {
        // 把input分割成IV和密文:
        byte[] iv = new byte[16];
        byte[] data = new byte[input.length - 16];
        
        System.arraycopy(input, 0, iv, 0, 16); // IV
        System.arraycopy(input, 16, data, 0, data.length); //密文
        System.out.println(Arrays.toString(iv));
        
        // 解密:
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); // 密码对象
        SecretKeySpec keySpec = new SecretKeySpec(key, "AES"); // 恢复秘钥
        IvParameterSpec ivps = new IvParameterSpec(iv); // 恢复IV
        
        // 初始化秘钥:操作模式、秘钥、IV参数
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivps);
        
        // 解密操作
        return cipher.doFinal(data);
    }
    
    // 合并数组
    public static byte[] join(byte[] bs1, byte[] bs2) {
        byte[] r = new byte[bs1.length + bs2.length];
        System.arraycopy(bs1, 0, r, 0, bs1.length);
        System.arraycopy(bs2, 0, r, bs1.length, bs2.length);
        return r;
    }
}

在CBC模式下，需要一个随机生成的16字节IV参数，必须使用SecureRandom生成。因为多了一个IvParameterSpec实例，因此，初始化方法需要调用Cipher的一个重载方法并传入IvParameterSpec。观察输出，可以发现每次生成的IV 不同，密文也不同。

非对成加密算法：

从DH算法我们可以看到，公钥-私钥组成的密钥对是非常有用的加密方式，因为公钥是可以公开的，而私钥是完全保密的，由此奠定了非对称加密的基础。

非对称加密:加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密。
例如:小明要加密一个文件发送给小红，他应该首先向小红索取她的公钥，然后，他用小红的公钥加密，把加密文件发送给小红，此文件只能由小红的私钥解开，因为小红的私钥在她自己手里，所以，除了小红，没有任何人能解开此文件。

非对称加密的典型算法就是RSA算法

非对称加密的优点:对称加密需要协商密钥，而非对称加密可以安全地公开各自的公钥，在N个人之间通信的时候:使用非对称加密只需要N个密钥对，每个人只管理自己的密钥对。而使用对称加密需要则需要N*(N-1/2个密钥，因此每个人需要管理N-1个密钥，密钥管理难度大，而且非常容易泄漏。

非对称加密的缺点:运算速度非常慢，比对称加密要慢很多

在实际应用的时候，非对称加密总是和对称加密一起使用，假设小明需要给小红需要传输加密文件，他俩首先交换了各自的公钥，然后:
1.小明生成一个随机的AES口令，然后用小红的公钥通过RSA加密这个口令，并发给小红;
2.小红用自己的 RSA 私钥解密得到AES 口令;
3.双方使用这个共享的AES 口令用 AES 加密通信。

RSA 算法的实现，示例代码如下:

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 Main {
	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("decrypted(解密): " + 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);
	}
}