devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java中常见哈希算法总结、对称式加密与非对称式加密的对比_java几种hash算法对比

作者：天景科技苑 | 2024-07-01 08:29:05

赞

踩

java几种hash算法对比

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

哈希算法

简介

  哈希算法（Hash）又称摘要算法(Digest)，它的作用是：对任意一组输入数据进行计算，得到一个固定长度的输出摘要。哈希算法的目的：验证原始数据是否被篡改。
哈希算法的特点：

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

哈希碰撞
  哈希碰撞是指，两个不同的输入得到了相同的输出：

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

  • 1
  • 2
  • 3
  • 4
  • 5

  碰撞是不能避免的，因为输出的字节长度是固定的，但是输入数据长度不固定，有无数种输入。因此哈希算法是把一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞。
所以碰撞的概率的高低关系到哈希算法的安全性。一个安全的哈希算法必须满足：

  • 碰撞概率低；
  • 不能猜测输出；

常用的哈希算法
  哈希算法的输出长度越长，就越难碰撞，碰撞概率越低，也就越安全。
常用的哈希算法

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();
		}
	}
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38

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());
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

Hmac算法

  Hmac(Hash-based Message Authentication Code)算法是一种基于密钥的消息认证算法，是一种更安全的消息摘要算法。Hmac可和哈希算法配合使用，例如Hmac MD5算法，它相当于“加盐”的MD5.相比于“加盐”的MD5，Hmac MD5会通过Java标准库的KeyGenerator生成一个安全的随机的key，它使用的key长度为64字节，更加安全，且Hmac是标准算法，通用性强，Hmac输出和原有的哈希算法长度一致。
HmacMD5的加密步骤：

  1. 获取基于HmacMD5的KeyGenerator实例；
  2. 通过KeyGenerator创建一个SecretKey实例；
  3. 通过名称HmacMD5获取Mac实例；
  4. 使用SecretKey初始化Mac实例；
  5. 调用update（）方法输入数据；
  6. 调用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);
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

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);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

对称加密算法

  常用的对称加密算法有：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);
	} 
	
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58

使用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;
	}

}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94

非对称加密算法

  非对称加密使用的是一个公钥-私钥对，加密和解密使用不同的密钥，只有同一个公钥-私钥对才能正常加密。例如，你要给对方发送一个加密文件，首先获取对方的公钥加密，然后对方通过与这个公钥相对的私钥进行解密，私钥只有对方有，所以除了对方没有任何人能解开此文件。
  非对称加密的典型算法为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);
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/775715
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号