哈希算法
简介
哈希算法（Hash）又称摘要算法(Digest)，它的作用是：对任意一组输入数据进行计算，得到一个固定长度的输出摘要。哈希算法的目的：验证原始数据是否被篡改。
哈希算法的特点：
- 相同的输入一定得到相同的输出；
- 不同的输入大概率得到不同的输出。
哈希碰撞
哈希碰撞是指，两个不同的输入得到了相同的输出：
"AaAaAa".hashCode(); // 0x7460e8c0
"BBAaBB".hashCode(); // 0x7460e8c0
"通话".hashCode(); // 0x11ff03
"重地".hashCode(); // 0x11ff03
碰撞是不能避免的，因为输出的字节长度是固定的，但是输入数据长度不固定，有无数种输入。因此哈希算法是把一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞。
所以碰撞的概率的高低关系到哈希算法的安全性。一个安全的哈希算法必须满足：
- 碰撞概率低；
- 不能猜测输出；
常用的哈希算法
哈希算法的输出长度越长，就越难碰撞，碰撞概率越低，也就越安全。
MD5算法
Java标准库提供了常用的哈希算法，并且有一套统一的接口，接下来先以MD5算法为例。直接上代码：
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
public class Test01 {
public static void main(String[] args) {
try {
//获取基于MD5加密算法的工具对象
MessageDigest md5 = MessageDigest.getInstance("MD5");
//更新原始数据
md5.update("Hello".getBytes());
md5.update("World".getBytes());
//获取加密后的结果
byte[] resultByteArray = md5.digest();
System.out.println(Arrays.toString(resultByteArray));
//加密后的字节数组转化为字符串
StringBuilder result = new StringBuilder();
for (byte b : resultByteArray) {
result.append(String.format("%02x",b)); //占两个字节的16进制不够两位用0补
}
System.out.println(result);
//只要内容相同，加密后结果相同
MessageDigest tempMd5 = MessageDigest.getInstance("MD5");
tempMd5.update("HelloWorld".getBytes());
byte[] tempResultByteArray = tempMd5.digest();
System.out.println(Arrays.toString(tempResultByteArray));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
}
SHA-1算法
SHA算法实际上是一个系列，包括SHA-0（已废弃）、SHA-1、SHA-256、SHA-512等。
在Java中使用SHA-1和MD5完全一样，只需要把算法名改为“SHA-1”，即创建MessageDigest实例时，将getInstance方法的参数改为“SHA-1”。
代码展示如下：
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());
}
}
Hmac算法
Hmac(Hash-based Message Authentication Code)算法是一种基于密钥的消息认证算法，是一种更安全的消息摘要算法。Hmac可和哈希算法配合使用，例如Hmac MD5算法，它相当于“加盐”的MD5.相比于“加盐”的MD5，Hmac MD5会通过Java标准库的KeyGenerator生成一个安全的随机的key，它使用的key长度为64字节，更加安全，且Hmac是标准算法，通用性强，Hmac输出和原有的哈希算法长度一致。
HmacMD5的加密步骤：
- 获取基于HmacMD5的KeyGenerator实例；
- 通过KeyGenerator创建一个SecretKey实例；
- 通过名称HmacMD5获取Mac实例；
- 使用SecretKey初始化Mac实例；
- 调用update（）方法输入数据；
- 调用Mac实例的doFinal（）方法获取最终的哈希值。
HmacMD5代码参考：
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
public class main {
public static void main(String[] args) throws NoSuchAlgorithmException, IllegalStateException, UnsupportedEncodingException, InvalidKeyException {
// 获取HmacMD5秘钥生成器
KeyGenerator keyGen = KeyGenerator.getInstance("HmacMD5");
// 产生秘钥
SecretKey secreKey = keyGen.generateKey();
// 打印随机生成的秘钥:
byte[] keyArray = secreKey.getEncoded();
StringBuilder key = new StringBuilder();
for(byte bite:keyArray) {
key.append(String.format("%02x", bite));
}
System.out.println(key);
// 使用HmacMD5加密
Mac mac = Mac.getInstance("HmacMD5");
mac.init(secreKey); // 初始化秘钥
mac.update("HelloWorld".getBytes("UTF-8"));
byte[] resultArray = mac.doFinal();
StringBuilder result = new StringBuilder();
for(byte bite:resultArray) {
result.append(String.format("%02x", bite));
}
System.out.println(result);
}
}
RipeMD160算法
RipeMD160是一个Java标准库中没有提供的一种算法。而BouncyCastle是一个提供了很多哈希算法和加密算法的第三方开源库，提供了一些Java标准库没有的算法，例如，RipeMD160哈希算法。
首先将BouncyCastle提供的jar包导入项目中，jar包可以从官网下载。
Java标准库的java.security包提供了一种标准机制，允许第三方提供商无缝接入。因此，在使用BouncyCastle提供的RipeMD160算法，需要先把BouncyCastle注册一下：
代码展示：
public class Main {
public static void main(String[] args) throws Exception {
// 注册BouncyCastle提供的通知类对象BouncyCastleProvider
Security.addProvider(new BouncyCastleProvider());
// 获取RipeMD160算法的"消息摘要对象"(加密对象)
MessageDigest md = MessageDigest.getInstance("RipeMD160");
// 更新原始数据
md.update("HelloWorld".getBytes());
// 获取消息摘要(加密)
byte[] result = md.digest();
// 消息摘要的字节长度和内容
System.out.println(result.length); // 160位=20字节
System.out.println(Arrays.toString(result));
// 16进制内容字符串
String hex = new BigInteger(1,result).toString(16);
System.out.println(hex.length()); // 20字节=40个字符
System.out.println(hex);
}
}
对称加密算法
常用的对称加密算法有：DES算法、AES算法、IDEA算法。AES算法是目前应用最广泛的加密算法，它常见的工作模式为ECB和CBC。密钥长度直接决定加密强度，而工作模式和填充模式可以看成是对称加密算法的参数和格式选择.java标准库提供的算法实现并不包括所有的工作模式和所有填充模式，但是通常我们只需要挑选常用的使用就可以了.
使用ECB模式加密和解密：
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
//AES对称加密
//ECB工作模式
public class Test01 {
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("加 密: "+Base64.getEncoder().encodeToString(encrypted));
//解密
byte[] decrypted = decrypt(key, encrypted);
System.out.println("解密: "+new String(decrypted));
}
public static byte[] encrypt(byte[] key,byte[] input) throws Exception{
//创建密码对象,需要传入算法/工作模式/填充模式
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 Exception {
//创建密码对象,需要传入算法/工作模式/填充模式
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);
}
}
使用CBC模式加密和解密：
CBC模式需要一个随机数作为IV参数，这样对于同一份明文，每次生成的密文都不一样。
在CBC模式下，需要一个随机生成的16字节IV参数，必须使用Securerandom生成.因为多了一个Ivparameterspec实例，因此，初始化方法需要调用Cipher的一个重载方法并传入Ivparameterspec。
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
//AES对称加密
//CBC工作模式
public class Test02 {
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("加 密: " + Base64.getEncoder().encodeToString(encrypted));
// 解密
byte[] decrypted = decrypt(key, encrypted);
System.out.println("解密: " + new String(decrypted));
}
public static byte[] encrypt(byte[] key, byte[] input) throws Exception {
// 创建密码对象,需要传入算法/工作模式/填充模式
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
// 根据key的字节内容,"恢复"密钥对象
SecretKey keySpec = new SecretKeySpec(key, "AES");
// CBC模式下需要生成一个16bytes的initialization vector：
SecureRandom sr = SecureRandom.getInstanceStrong();
byte[] iv = sr.generateSeed(16);// 生成16个字节的随机数
System.out.println("随机数的字节数组："+Arrays.toString(iv));
// 随机数封装成IvParameterSpec对象
IvParameterSpec ivps = new IvParameterSpec(iv);
// 初始化密钥：设置加密模式ENCRYPT_MODE，密钥，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 Exception {
// 把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");//密码对象
// 根据key的字节内容,"恢复"密钥对象
SecretKey keySpec = new SecretKeySpec(key, "AES");//恢复密钥
// 随机数封装成IvParameterSpec对象
IvParameterSpec ivps = new IvParameterSpec(iv);//恢复IV
// 初始化密钥：设置解密模式.DECRYPT_MODE
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;
}
}
非对称加密算法
非对称加密使用的是一个公钥-私钥对，加密和解密使用不同的密钥，只有同一个公钥-私钥对才能正常加密。例如，你要给对方发送一个加密文件，首先获取对方的公钥加密，然后对方通过与这个公钥相对的私钥进行解密，私钥只有对方有，所以除了对方没有任何人能解开此文件。
非对称加密的典型算法为RSA算法，对称加密需要协商密钥，而非对称加密可以安全地公开各自的公钥，在n个人之间通信的时候:使用非对称加密只需要n个密钥对，每个人只管理自己的密钥对.而使用对称加密需要则需要n*(n-1)/2个密钥，因此每个人需要管理N-1个密钥，密钥管理难度大，而且非常容易泄漏，且运算速度非常慢，比对称加密要慢很多。
Java标准库提供了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 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);
}
}
3545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
