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

最新推荐文章于 2023-07-03 23:30:00 发布

雾远望

最新推荐文章于 2023-07-03 23:30:00 发布

阅读量1.6k

点赞数 136

文章标签： java 哈希算法开发语言

本文链接：https://blog.csdn.net/w259149/article/details/125919051

版权

哈希算法

概述

哈希算法又称摘要算法，将任意一组数据利用指定算法得到一个固定长度的字节数组(输出摘要)，目的是为了验证原始数据是否被篡改；

特点

当原始数据相同时，经过哈希算法所得到的结果一定相同

当原始数据不同时，经过哈希算法所得到的结果可能相同（哈希碰撞）

哈希碰撞：输入两个不同数据得到相同的输出结果；当然哈希碰撞是不可避免的，原因是输出字节的长度是固定的，而输入的数据长度却是不固定的，将一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞

一个安全的哈希算法必须满足：碰撞概率低、输出结果无规律

输出结果无规律：输入任意一个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位；使用对称加密算法需要指定算法名称、工作模式和填充模式。

非对称加密就是加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密；

雾远望

关注

136
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
2
评论
Java加密总结：常见哈希算法总结、对称式加密与非对称式加密的对比

对称加密算法就是传统的用一个密码进行加密和解密；非对称加密是指加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密。典型的非对称式加密算法就是RSA算法；//RSA//明文//创建公钥／私钥对//用Alice的公钥加密//获取Alice的公钥，并输出System.out.println(String.format("publickey(公钥)//使用公钥加密//用Alice的私钥解密//获取Alice的私钥，并输出。...
复制链接

扫一扫