java 对pdf哈希值进行签名 java哈希算法

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

哈希算法最重要的特点就是：

相同的输入一定得到相同的输出；

不同的输入大概率得到不同的输出。

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

"AaAaAa".hashCode(); // 0x7460e8c0
"BBAaBB".hashCode(); // 0x7460e8c0

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

哈希碰撞是不可避免的，因为输出的字节长度是固定的，String的hashCode()输出是4字节整数，最多只有4294967296种输出，但输入的数据长度是不固定的，有无数种输入。所以，哈希算法是把一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞。既然哈希碰撞不可避免，那我们就得想办法去降低这种碰撞的概率，因为碰撞概率的高低关系到哈希算法的安全性。一个安全的哈希算法必须满足：
●碰撞概率低；
●不能猜测输出。
不能猜测输出是指：输入的任意一个bit的变化会造成输出完全不同，这样就很难从输出反推输入（只能依靠暴力穷举）。

常见的哈希算法有：

常见的哈希算法

算法	输出长度（位）	输出长度（字节）
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

首先我们来看用MD5算法来计算哈希，代码实现如下：

package com.hpc.wyj02;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

public class Demo01 {
	public static void main(String[] args) {
		try {
			//获取基于MD5加密算法的工具对象
			MessageDigest md5=MessageDigest.getInstance("MD5");

			//更新原始数据
			md5.update("Hello".getBytes());
			md5.update("World".getBytes());

			//获取加密后的结果
			byte[] result=md5.digest();
			System.out.println(Arrays.toString(result));
		
			StringBuilder sb = new StringBuilder();
			for(byte bite : result) {
			     sb.append(String.format("%02x", bite));
			   }
			        
			  System.out.println(sb.toString());
	
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
	}

}

运行结果如下：

哈希算法的用途：

1、校验下载文件：

因为相同的输入永远会得到相同的输出，因此，如果输入被修改了，得到的输出就会不同。我们在网站上下载软件的时候，经常看到下载页显示的MD5哈希值：

 我们只需要自己计算一下本地文件的哈希值，再与官网公开的哈希值对比，如果相同，说明文件下载正确，否则，说明文件已被篡改。

2、存储用户密码

如果直接将用户的原始口令存放到数据库中，会产生极大的安全风险：
●数据库管理员能够看到用户明文口令；
●数据库数据一旦泄漏，黑客即可获取用户明文口令。

为了防止这些安全问题，我们可以存储用户口令的哈希，例如，MD5。在用户输入原始口令后，系统计算用户输入的原始口令的MD5并与数据库存储的MD5对比，如果一致，说明口令正确，否则，口令错误。这样，即使数据库泄漏，黑客也无法拿到用户的原始口令。

使用哈希口令时，还要注意防止彩虹表攻击。什么是彩虹表呢？上面讲到了，如果只拿到MD5，从MD5反推明文口令，只能使用暴力穷举的方法。然而黑客并不笨，暴力穷举会消耗大量的算力和时间。但是，如果有一个预先计算好的常用口令和它们的MD5的对照表，这个表就是彩虹表。如果用户使用了常用口令，黑客从MD5一下就能反查到原始口令：

 这就是为什么不要使用常用密码，以及不要使用生日作为密码的原因。

当然，我们也可以采取特殊措施来抵御彩虹表攻击：对每个口令额外添加随机数，这个方法称之为加盐（salt）：
digest = md5(salt + inputPassword)
经过加盐处理的数据库表，内容如下：

 SHA-1也是一种哈希算法，它的输出是160 bits，即20字节。SHA-1是由美国国家安全局开发的，SHA算法实际上是一个系列，包括SHA-0（已废弃）、SHA-1、SHA-256、SHA-512等。
在Java中使用SHA-1，和MD5完全一样，只需要把算法名称改为"SHA-1"：

package com.hpc.wyj02;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

public class Demo01 {
	public static void main(String[] args) {
		try {
			//获取基于SHA-1加密算法的工具对象
			MessageDigest md5=MessageDigest.getInstance("SHA-1");

			//更新原始数据
			md5.update("Hello".getBytes());
			md5.update("World".getBytes());

			//获取加密后的结果
            //20 bytes
			byte[] result=md5.digest();
			System.out.println(Arrays.toString(result));
		
			StringBuilder sb = new StringBuilder();
			for(byte bite : result) {
			     sb.append(String.format("%02x", bite));
			   }
			        
			  System.out.println(sb.toString());
	
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
	}

}

运行结果如下：

当我们想用某种算法，Java标准库没有提供怎么办？这时，我们就得找一个现成的第三方库，直接使用。

BouncyCastle就是一个提供了很多哈希算法和加密算法的第三方开源库。它提供了Java标准库没有的一些算法，例如，RipeMD160哈希算法。RIPEMD160是一种基于Merkle-Damgård结构的加密哈希函数，它是比特币标准之一。RIPEMD-160是RIPEMD算法的增强版本，RIPEMD-160算法可以产生出160位的的哈希摘要。

当我们要用这种算法时，我们必须把BouncyCastle提供的bcprov-jdk15on-1.70.jar添加至classpath。这个jar包可以从官方网站下载。

Java标准库的java.security包提供了一种标准机制，允许第三方提供商无缝接入。我们要使用BouncyCastle提供的RipeMD160算法，需要先把BouncyCastle注册一下：

package com.hpc.wyj03;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.util.Arrays;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class Demo01 {
	public static void main(String[] args) {
		try {
			//注册BouncyCastle提供的通知类对象BouncyCastleProvider
			Security.addProvider(new BouncyCastleProvider()) ;

			//获取RipeMD160算法的”消息摘要对象“(加密对象)
			MessageDigest digest=MessageDigest.getInstance("RipeMD160");

			//更新原始数据
			digest.update("HelloWord".getBytes());

			//获取消息摘要
			byte[] result=digest.digest();

			//输出消息摘要的内容和字节长度
			System.out.println(Arrays.toString(result));
			System.out.println(result.length);

			//16进制字符串内容
			String s=new BigInteger(1,result).toString(16);

			System.out.println(s);    //20字节=40字符
			System.out.println(s.length());
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
	}

}

运行结果如下：

 对称加密算法

对称加密算法就是传统的用一个密码进行加密和解密。在软件开发中，常用的对称加密算法有：

注意：DES算法由于密钥过短，可以在短时间内被暴力破解，所以现在已经不安全了。

使用AES加密：

 AES算法是目前应用最广泛的加密算法。比较常见的工作模式是ECB和CBC。

用ECB模式加密和解密结果如下：

package com.hpc.wyj03;

import java.security.GeneralSecurityException;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 * AES
 * EBC
 * @author 我
 *
 */
public class Demo02 {
	public static void main(String[] args) throws 
                        NoSuchAlgorithmException, GeneralSecurityException {
		//原文
		String s="lovejj";

		//秘钥数组
		//128位=16 bytes
		byte[] key="qwertyuiop123456".getBytes();

		System.out.println("秘钥数组："+Arrays.toString(key));
		System.out.println("秘钥数组长度："+key.length+"字节");

		//加密
		byte[] data=s.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 
                    NoSuchAlgorithmException, GeneralSecurityException { 

		//创建密码对象，需要传入算法/工作模式/填充模式
		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 
                    NoSuchAlgorithmException, GeneralSecurityException {

		//创建密码对象，需要传入算法/工作模式/填充模式
		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);
		
	}
}

运行结果如下：

 Java标准库提供的对称加密接口非常简单，使用时按以下步骤编写代码：

1根据算法名称/工作模式/填充模式获取Cipher实例；
2根据算法名称初始化一个SecretKey实例，密钥必须是指定长度；
3使用SerectKey初始化Cipher实例，并设置加密或解密模式；
4传入明文或密文，获得密文或明文。

ECB模式是最简单的AES加密模式，它只需要一个固定长度的密钥，固定的明文会生成固定的密文，这种一对一的加密方式会导致安全性降低，更好的方式是通过CBC模式，它需要一个随机数作为IV参数，这样对于同一份明文，每次生成的密文都不同，具体实现代码如下：

package com.hpc.wyj03;

import java.security.GeneralSecurityException;
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 Demo03 {
	public static void main(String[] args) throws 
                             NoSuchPaddingException, GeneralSecurityException {
		//原文
		String s="lovejj";

		//秘钥数组
		//256位=32 bytes
		byte[] key="qwertyuiopasdfghjklzxcvbnm123456".getBytes();

		System.out.println("秘钥数组："+Arrays.toString(key));
		System.out.println("秘钥数组长度："+key.length+"字节");

		//加密
		byte[] data=s.getBytes();
		byte[] encrypted=encrypt(key, data);
		System.out.println("Encrypted(加密)："
                             +Base64.getEncoder().encodeToString(encrypted));

		//解密
		byte[] decrypted=decrypt(key, encrypted);
		System.out.println("Dncrypted(解密)："+new String(decrypted));
	}


	//加密方法
	public static byte[] encrypt(byte[] key,byte[] input) throws 
                               GeneralSecurityException, NoSuchPaddingException {

		//创建密码对象，需要传入算法/工作模式CBC/填充模式
		Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");

		//根据key的字节内容，”恢复“秘钥对象
		SecretKey keySpec=new SecretKeySpec(key,"AES");

		//CBC模式需要生成一个16bytes的initialization vector
		SecureRandom sr=SecureRandom.getInstanceStrong();

         //生成16个字节的随机数
		byte[] iv=sr.generateSeed(16);    
		System.out.println("IV："+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不需要保密
		return jion(iv,data);
	}
	//解密方法
	public static byte[] decrypt(byte[] key,byte[] input) throws 
            BadPaddingException, NoSuchAlgorithmException, GeneralSecurityException {

		//分割数组
		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("IV："+Arrays.toString(iv));

		//创建密码对象，需要传入算法/工作模式/填充模式
		Cipher cipher=Cipher.getInstance("AES/CBC/PKCS5Padding");

		//根据key的字节内容，”恢复“秘钥对象
		SecretKeySpec keySpec=new SecretKeySpec(key, "AES");
		IvParameterSpec ivps=new IvParameterSpec(iv);   //恢复IV

		//初始化秘钥：设置解密模式ENCRYPT_MODE、秘钥、IV
		cipher.init(Cipher.DECRYPT_MODE, keySpec,ivps);

		//根据原始内容(字节)，进行解密
		return cipher.doFinal(data);
	}

	//拼接方法
	public static byte[] jion(byte[] b1,byte[] b2) {
		byte[] b=new byte[b1.length+b2.length];
		System.arraycopy(b1, 0, b, 0, b1.length);
		System.arraycopy(b2, 0, b, b1.length, b2.length);
		return b;
	}
}

运行结果如下：

 在CBC模式下，需要一个随机生成的16字节IV参数，观察输出，可以发现每次生成的IV不同，密文也不同。

非对称加密算法

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

非对称加密的典型算法就是RSA算法，它是由Ron Rivest，Adi Shamir，Leonard Adleman这三个人一起发明的，所以用他们三个人的姓氏首字母缩写表示。

非对称加密的优点：对称加密需要协商密钥，而非对称加密可以安全地公开各自的公钥，在N个人之间通信的时候：使用非对称加密只需要N个密钥对，每个人只管理自己的密钥对。而使用对称加密需要则需要N*(N-1)/2个密钥，因此每个人需要管理N-1个密钥，密钥管理难度大，而且非常容易泄漏。

非对称加密的缺点：运算速度非常慢，比对称加密要慢很多。

RSA算法的代码实现如下：

package com.hpc.wyj05;

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;

public class RSA01 {


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

}

运行结果如下：

 总的来说，对称加密算法使用同一个密钥进行加密和解密，非对称加密算法就是加密(公钥)和解密(私钥)使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密。