常见哈希算法；加密算法，对称式加密与非对称式加密的对比
哈希算法
哈希算法又称哈希摘要算法。他一般是对一个目标，一个对象，一些字节码，摘取一部分进行计算，得到一个固定长长度的输出摘要。一般而言哈希算法的目的是未来验证原始数据是否被篡改。
在Javaz中字符串的hashCode()就是一个哈希算法，它的输入是任意字符串，输入是固定的4字节int整数:
"hello".hashCode(); // 0x5e918d2
"hello, java".hashCode(); // 0x7a9d88e8
"hello, bob".hashCode(); // 0xa0dbae2f
哈希算法的特点
相同的输入一定得到相同的输出；
不同的输入大概率得到不同的输出；
从这两个特点就可以看出，有可能不同的输入，得到相同的哈希值。
我们把这种情况叫做哈希碰撞
哈希碰撞是指：两个不同的输入得到相同的输出：
理论上讲，哈希碰撞一定存在，因为输出的字节长度是固定的，但是输入的值是无穷的，是没有限制的。无穷对应有穷，一定会有重复。
碰撞显然是不好的，如何降低碰撞的概率是研究哈希算法的安全性的必要性。一个安全的哈希算法必须满足：
1碰撞概率低
2不能被猜测输出
根据碰撞概率，哈希算法的输出长度越长，就越难产生碰撞，也就越加安全
常用的的哈希算法：
java的标准库中提供了常用的哈希算法，并且有一套统一的接口。以MD5为例：
i
```java
mport 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());
}
}
使用MeeasgeDIge时，我们首先根据哈希算法获取一个MessagDigest实例，然后反复调用update（byte[]）输入数据，当输入结束后，调用digest()方法byte[]数组表示的摘要，最后，把它转换为十六进制的字符串。
运行上述代码，可以得到HelloWorld的MD5是68e109f40c72a15e05cc22786f8e6。
哈希算法用途
可以用来校验下载文件和储存用户密码
校验下载文件：
因为相同的输入会得到相同的输出，因此，如果输入被修改了，得到的输出就会不同。只要计算一下本地文件的哈希值，再与官网公开的哈希值对比，相同，就说明文件下载正常，否则文件被篡改。
存储用户密码：
在数据库中存储用户口令的哈希值，只要用户输入原始口令后，系统计算用户输入的原始口令的哈希值，与保存在数据库重点哈希值相等就说明口令正确。
使用哈希值作为口令的时候，还需要防止彩虹表攻击。彩虹表是什么呢？彩虹表就是一个已经计算好常用口令和它们的MD5的对照表，这个表就是彩虹表。如果有用户使用了常用口令，从彩虹表就可以反差到原始口令。
我们可以采用加盐的方法来抵御彩虹表的攻击：对每个口令额外添加随机书，这个方法称之为加盐（salt）
digest=md5(salt+inputPassword);
SHA-1算法和MD5一样也是一种哈希算法，他输出是160bits，即是20字节。还有SHA-256 SHA-512等
import java.security.MessageDigest;
public class main {
public static void main(String[] args) {
// 创建一个MessageDigest实例:
MessageDigest md = MessageDigest.getInstance(“SHA-1”);
// 反复调用update输入数据:
md.update("Hello".getBytes("UTF-8"));
md.update("World".getBytes("UTF-8"));
// 20 bytes: db8ac1c259eb89d4a131b253bacfca5f319d54f2
byte[] results = md.digest();
StringBuilder sb = new StringBuilder();
for(byte bite : results) {
sb.append(String.format("%02x", bite));
}
System.out.println(sb.toString());
}
}
对称式加密：
对称加密算法就是传统的用一个密码进行加密和解密。例如，我们常用的 WinZIP 和WinRAR对压缩包的加密和解密，就是使用对称加密算法。
从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文:
secret = encrypt(key,message);
而解密则相反，它接收密码和密文，然后输出明文:
plain = decrypt(key,secret);
密钥长度直接决定加密强度，而工作模式和填充模式可以看成是对称加密算法的参数和格式选择。Java标准库提供的算法实现并不包括所有的工作模式和所有填充模式，但是通常我们只需要挑选常用的使用就可以了。
最后注意， DES 算法由于密钥过短，可以在短时间内被暴力破解，所以现在已经不安全了。
、
**用AES算法加密**
使用AES算法的ECB模式加密并解密。
```java
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);
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");
SecretKey keySpec = new SecretKeySpec(key, "AES");
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");
SecretKey keySpec = new SecretKeySpec(key, "AES");
cipher.init(Cipher.DECRYPT_MODE, keySpec);
return cipher.doFinal(input);
}
}
CBC模式
cbc模式是在原来的AES加密模式的基础加入了一个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生成。因为多了一个IvOArameterSpec实例，因此初始化需要调用Cipher的重载方法并且传入IvParameterSpec/
非对称加密:加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密。
例如:小明要加密一个文件发送给小红，他应该首先向小红索取她的公钥，然后，他用小红的公钥加密，把加密文件发送给小红，此文件只能由小红的私钥解开，因为小红的私钥在她自己手里，所以，除了小红，没有任何人能解开此文件。
非对称加密的典型算法就是RSA算法
非对称加密的缺点:运算速度非常慢，比对称加密要慢很多
在实际应用的时候，非对称加密总是和对称加密一起使用，假设小明需要给小红需要传输加密文件，他俩首先交换了各自的公钥，然后:
1.小明生成一个随机的AES口令，然后用小红的公钥通过RSA加密这个口令，并发给小红;
2.小红用自己的 RSA 私钥解密得到AES 口令;
3.双方使用这个共享的AES 口令用 AES 加密通信。
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);
}
}