哈希算法
概述
哈希算法又称摘要算法,将任意一组数据利用指定算法得到一个固定长度的字节数组(输出摘要),目的是为了验证原始数据是否被篡改;
特点
当原始数据相同时,经过哈希算法所得到的结果一定相同
当原始数据不同时,经过哈希算法所得到的结果可能相同(哈希碰撞)
哈希碰撞:输入两个不同数据得到相同的输出结果;当然哈希碰撞是不可避免的,原因是输出字节的长度是固定的,而输入的数据长度却是不固定的,将一个无限的输入集合映射到一个有限的输出集合,必然会产生碰撞
一个安全的哈希算法必须满足:碰撞概率低、输出结果无规律
输出结果无规律:输入任意一个bit所造成的输出结果完全不同,很难从输出结果反推出输入数据(只能依赖暴力穷举)
用途
校验下载文件
判断下载到本地的软件是否是未经篡改的文件?我们只需要自己计算一下本地文件的哈希值,再与官网公开的哈希值对比,如果相同,说明文件下载正确,否则,说明文件已被篡改。
储存用户密码
如果将用户的原始口令直接存放到数据库中,数据库数据一旦泄漏,黑客会直接获取用户明文口令。那么我们就应该存储用户口令的哈希,例如在用户输入原始口令后,系统计算用户输入的原始口令的MD5并与数据库存储的MD5对比,如果一致,说明口令正确,否则,口令错误。即使数据库泄漏,黑客也无法拿到用户的原始口令。想要拿到用户的原始口令,必须用暴力穷举的方法逐个尝试直到某个口令计算的MD5恰好等于指定值。
使用哈希口令时,还要注意防止彩虹表攻击。彩虹表是一个预先计算好的常用口令,用彩虹表和它们的MD5表对照,如果用户使用了常用口令,黑客从MD5一下就能反查到原始口令; 这就是为什么不要使用常用密码,以及不要使用生日作为密码的原因。
常用哈希算法
算法 | 输出长度(位) | 输出字节长度 |
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 |
SHA-1
Java标准库提供了常用的算法,并且不同算法的代码形式相同,我们以SHA-1为例,观察如何利用哈希算法得到加密字节数组:
public class Hash01 {
public static void main(String[] args) throws NoSuchAlgorithmException {
//获取基于SHA-1加密算法的工具对象
MessageDigest mds=MessageDigest.getInstance("SHA-1");
//更新原始数据
mds.update("hello".getBytes());
mds.update("would".getBytes());
//获取加密后的结果
byte[] resultByteArray=mds.digest();
System.out.println("加密后字节数组结果:"+Arrays.toString(resultByteArray));
//只要内容相同,加密结果就相同
MessageDigest tempMds=MessageDigest.getInstance("SHA-1");
tempMds.update("hellowould".getBytes());
byte[] tempresultByteArray=tempMds.digest();
System.out.println("相同数据加密后字节数组结果:"+Arrays.toString(tempresultByteArray));
}
}
代码输出结果:
加密后字节数组结果:[-123, -47, -11, -94, -101, -78, -6, -76, 41, -73, 26, 14, -124, 5, -17, -28, 29, 79, -104, -108]
相同数据加密后字节数组结果:[-123, -47, -11, -94, -101, -78, -6, -76, 41, -73, 26, 14, -124, 5, -17, -28, 29, 79, -104, -108]
我们可以将字节数组处理成一段编码:
StringBuilder resultStr=new StringBuilder();
for(byte bit:resultByteArray) {
resultStr.append(String.format("%02x", bit));
}
System.out.println("处理后密文:"+resultStr);
System.out.println("处理后密文长度:"+resultStr.length());
编码结果:
处理后密文:85d1f5a29bb2fab429b71a0e8405efe41d4f9894
处理后密文长度:40
类似的,计算MD5、SHA-256、SHA-512只要传入相应的哈希算法名称,Java标准库支持的哈希算法都可以使用此代码形式得到密文;
RipeMD-160
不过虽然Java标准库中提供了一系列常用的标准算法,仍然有一些我们想用的某种算法没有在标准库里;
解决的方式有两种:一是自己写,二是找一个现成的第三方库直接使用
在这里我们就不得不提到一个第三方开源库:BouncyCastle ,它提供了一些Java标准库没有的一些算法,例如:RipeMD160算法;
RipeMD160是基于Merkle-Damgård结构的加密哈希算法,它是比特币的标准之一。RipeMD160是RIPEMD的增强版本,RipeMD160算法可以产生160位哈希摘要;
用法
在使用RipeMD160算法之前,我们必须要把BouncyCastle 提供的bcprov-jdk5on-1.70.jar添加至classpath,添加成功jar包后,就可以使用java.security包下提供的一种标准机制,允许第三方库无缝接入;
要使用BouncyCastle 提供的RipeMD160算法需要先注册BouncyCastle,在这里我们就要提到security类提供的addProvider(Provider provider)方法,他的作用就是:注册bouncycastle类提供的通知类对象BouncyCastleProvider
public static int addProvider(Provider provider) {
/*
* We can't assign a position here because the statically
* registered providers may not have been installed yet.
* insertProviderAt() will fix that value after it has
* loaded the static providers.
*/
return insertProviderAt(provider, 0);
}
代码如下:
//使用第三方类库bouncycastle提供RipeMD160算法加密
public class Bouncy01 {
public static void main(String[] args) {
try {
//注册bouncycastle类提供的通知类对象BouncyCastleProvider
Security.addProvider(new BouncyCastleProvider());
//获取RipeMD160算法的摘要对象(加密信息)
MessageDigest digest=MessageDigest.getInstance("RipeMD160");
//更新原始数据
digest.update("helloWould".getBytes());
//获取信息摘要(加密)
byte[] resultByteArray=digest.digest();
//信息摘要的字节长度和内容
System.out.println(Arrays.toString(resultByteArray));
System.out.println(resultByteArray.length);
//十六进制内容字符串
String hex=new BigInteger(1, resultByteArray).toString(16);
System.out.println(hex);
System.out.println(hex.length());
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
对称式加密
概述
对称加密算法就是传统的用一个密码进行加密和解密;
常用对称算法
算法 | 密钥长度 | 工作模式 | 填充模式 |
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/... |
注:由于DES密钥过短,可以在短时间内被暴力破解,并不推荐使用
密钥长度直接决定加密强度,而工作模式和填充模式相当于是对称算法的参数和格式选择,Java标准库并不包括所有的工作模式和填充模式,一般情况选择常用的就可以了;
AES算法
AES算法目前是应用最广泛的加密运算,常见工作模式:ECB、CBC;
ECB模式
ECB模式是最简单的AES加密模式,它只需要一个固定长度的密钥,固定的明文会生成固定的密文,这种一对一的加密方式会导致安全性降低;
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 Aes01 {
public static void main(String[] args) {
try {
//原文
String password="hello,world";
//128位密钥==16 bytes key
byte[] key="1234567890abcdef".getBytes();
//加密
byte[] data=password.getBytes();
byte[] encrypted=encrypt(key, data);
System.out.println("加密:"+Base64.getEncoder().encodeToString(encrypted));
//解密
System.out.println("解密:"+new String(decrypt(key, encrypted)));
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
}
//加密
public static byte[] encrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
//创建密码对象,需要传入算法/工作模式/填充模式
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
//根据key的字节内容,回复密钥对象
SecretKey keySpec=new SecretKeySpec(key, "AES");
//初始化密钥:设置加密模式
cipher.init(Cipher.ENCRYPT_MODE, keySpec);
//根据原始内容(字节),进行加密
return cipher.doFinal(data);
}
//解密
public static byte[] decrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
//创建密码对象,需要传入算法/工作模式/填充模式
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
//根据key的字节内容,回复密钥对象
SecretKey keySpec=new SecretKeySpec(key, "AES");
//初始化密钥:设置解密模式
cipher.init(Cipher.DECRYPT_MODE, keySpec);
//根据原始内容(字节),进行解密
return cipher.doFinal(data);
}
}
CBC模式
在CBC模式下,需要一个随机生成的16字节IV参数,必须使用SecureRandom生成。因为多了一个IvParameterSpec实例,因此,初始化方法需要调用Cipher的一个重载方法并传入IvParameterSpec。观察输出,可以发现每次生成的IV不同,密文也不同;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
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.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
public class Cbc01 {
public static void main(String[] args) {
try {
//原文
String password="hello,world";
//128位密钥==16 bytes key
byte[] key="1234567890abcdef1234567890abcdef".getBytes();
//加密
byte[] data=password.getBytes();
byte[] encrypted=encrypt(key, data);
System.out.println("加密数组:"+Arrays.toString(encrypted));
System.out.println("加密:"+Base64.getEncoder().encodeToString(encrypted));
//解密
System.out.println("解密:"+new String(decrypt(key, encrypted)));
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (InvalidAlgorithmParameterException e) {
e.printStackTrace();
}
}
//加密
public static byte[] encrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
//创建密码对象,需要传入算法/工作模式/填充模式
Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
//根据key的字节内容,回复密钥对象
SecretKey keySpec=new SecretKeySpec(key, "AES");
//CBC模式需要生成一个16bytes的initialization vector(iv)
SecureRandom random=SecureRandom.getInstanceStrong();
byte[] iv=random.generateSeed(16);//生成16个字节的随机数
System.out.println(Arrays.toString(iv));
IvParameterSpec ivps=new IvParameterSpec(iv);//随机数封装为IvParameterSpec参数
//初始化密钥:设置加密模式,密钥,iv参数
cipher.init(Cipher.ENCRYPT_MODE, keySpec,ivps);
//加密
byte[] encry=cipher.doFinal(data);
//iv不需要保密,把iv和密文一起返回
return join(iv,encry);
}
//解密
public static byte[] decrypt(byte[] key,byte[] data) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
//把data分割成IV和密文
byte[] iv=new byte[16];
byte[] encry=new byte[data.length-16];
System.arraycopy(data, 0, iv, 0, iv.length);//iv
System.arraycopy(data, iv.length, encry, 0, encry.length);//密文
// System.out.println(Arrays.toString(iv));
// System.out.println(Arrays.toString(encry));
//解密:
//创建密码对象,需要传入算法/工作模式/填充模式
Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");
//根据key的字节内容,回复密钥对象
SecretKey keySpec=new SecretKeySpec(key, "AES");
IvParameterSpec ivps=new IvParameterSpec(iv);
//初始化密钥:设置解密模式
cipher.init(Cipher.DECRYPT_MODE, keySpec,ivps);
//根据原始内容(字节),进行解密
return cipher.doFinal(encry);
}
public static byte[] join(byte[] iv,byte[] encry) {
byte[] r=new byte[iv.length+encry.length];
System.arraycopy(iv, 0, r, 0, iv.length);
System.arraycopy(encry, 0, r, iv.length, encry.length);
System.out.println("iv:"+Arrays.toString(iv));
System.out.println("密文:"+Arrays.toString(encry));
return r;
}
}
非对称式加密
概述
非对称加密是指加密和解密使用的不是相同的密钥,只有同一个公钥-私钥对才能正常加解密。典型的非对称式加密算法就是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 KeyPairRSA {
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("publickey(公钥):%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("privatekey(私钥):%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);
}
}
、
总结
哈希算法可用于验证数据完整性,具有防篡改检测的功能;常用的哈希算法有MD5、SHA-1等;用哈希存储口令时要考虑彩虹表攻击。
对称加密算法使用同一个密钥进行加密和解密,常用算法有DES、AES和IDEA等; 密钥长度由算法设计决定,AES的密钥长度是128/192/256位;使用对称加密算法需要指定算法名称、工作模式和填充模式。
非对称加密就是加密和解密使用的不是相同的密钥,只有同一个公钥-私钥对才能正常加解密;