密码学

1. 密码学
- 1.1. 密码学基本概念
- 1.2 密码学的历史
- - 1.2.1 古典密码学
  - - 1.2.1.1. 替换法
    - 1.2.1.2移位法
    - 1.2.1.2 古代密码学的破解方式
  - 1.2.2 进代密码学
  - 1.2.3 现代密码学
  - - 1.2.3.1 散列函数
    - 1.2.3.2 对称密码
    - 1.2.3.3 非对称密码
  - 1.2.4 如何设置密码才安全
- 1.2.5 ASCII编码
- 1.3 凯撒加密
- - 1.3.1 中国古代加密
  - 1.3.2 外国加密
  - 1.3.3 凯撒加密解密
- 1.4 频度分析法破解恺撒加密
- - - 密码棒
  - 频率分析解密法
- 1.5 Byte与bit
- 1.6 常见加密方式
- - 1.6.1 对称加密
  - 1.6.2 DES加解密
- 1.7 base64
- - toString与new String的区别
- 1.8 AES加密
- 1.9 加密模式
- - 1.9.1 ECB
  - 1.9.2 CBC
  - 1.9.3 加密模式总结
  - 1.9.4 加密模式的使用
- 1.10 填充模式
- - NoPadding
  - PKCS5Padding
  - Tips
  - 加密模式和填充模式
- 1.11 消息摘要
- - 1.11.1 特点
  - 1.11.2 MD5算法的实现
  - 1.11.2其他数字摘要算法
- 1.12 非对称加密
- - 简介：
  - 示例
- 特点
- - 常见算法
  - 1.12.1 生成公钥和私钥
  - 1.12.2 私钥加密
  - 1.12.3 私钥加密公钥解密
  - 1.12.4 加密解密方法的提取
  - 1.12.5 读取公钥和私钥
  - 1.12.6 Hutool工具类实现RSA加解密
- 1.13 数字签名
- - 1.13.1 简单认识
  - 1.13.2 基本原理
  - 1.13.3 数字证书
  - 1.13.4 网页加密
  - 1.13.5 代码实现

1. 密码学

1.1. 密码学基本概念

密码：微信、QQ、支付宝等已经开始使用密码
密码学：网络安全、信息安全、区块链这些学科的基础
密码学已经存在好几千年

1.2 密码学的历史

1.2.1 古典密码学

古代就已经开始使用密码学，目的就是保护信息安全

1.2.1.1. 替换法

使用固定的信息，将原文替换成密文
例如：bee,将b替换成w，e替换成p，单词就变成wpp
替换法有单表替换和多表替换两种形式。

单表替换
单表替换即只有一张原文密文对照表单，发送者和接收者用这张表单来加密解密。在上述例子中，表单即为：bee - wpp。
多表替换
多表替换即有多张原文密文对照表单，不同字母可以用不同表单的内容替换。
例如约定好表单为：表单 1：abcde-swtrp 、表单2：abcde-chfhk 、表单 3：abcde-jftou。
规定第一个字母用第三张表单，第二个字母用第一张表单，第三个字母用第二张表单，这时 bee单词就变成了（312）fpk

1.2.1.2移位法

移位法就是将原文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后得出密文，典型的移位法应用有 “ 恺撒密码 ”。

例如约定好向后移动2位（abcde - cdefg），这样 bee 单词就变换成了dgg 。
同理替换法，移位法也可以采用多表移位的方式，典型的多表案例是“维尼吉亚密码”（又译维热纳尔密码），属于多表密码的一种

1.2.1.2 古代密码学的破解方式

频率分析法：概率论
古典密码虽然很简单，但是在密码史上是使用的最久的加密方式，直到“概率论”的数学方法被发现，古典密码就被破解了。
英文单词中字母出现的频率是不同的，e以12.702%的百分比占比最高，z 只占到0.074%，感兴趣的可以去百科查字母频率详细统计数据。如果密文数量足够大，仅仅采用频度分析法就可以破解单表的替换法或移位法。
多表的替换法或移位法虽然难度高一些，但如果数据量足够大的话，也是可以破解的。以维尼吉亚密码算法为例，破解方法就是先找出密文中完全相同的字母串，猜测密钥长度，得到密钥长度后再把同组的密文放在一起，使用频率分析法破解。

1.2.2 进代密码学

古典密码的安全性受到了威胁，外加使用便利性较低，到了工业化时代，近现代密码被广泛应用。

恩尼格玛机
恩尼格玛机是二战时期纳粹德国使用的加密机器，后被英国破译，参与破译的人员有被称为计算机科学之父、人工智能之父的图灵。

恩尼格玛机
恩尼格玛机使用的加密方式本质上还是移位和替代，只不过因为密码表种类极多，破解难度高，同时加密解密机器化，使用便捷，因而在二战时期得以使用。

1.2.3 现代密码学

1.2.3.1 散列函数

散列函数，也见杂凑函数、摘要函数或哈希函数，可将任意长度的消息经过运算，变成固定长度数值，常见的有MD5、SHA-1、SHA256，多应用在文件校验，数字签名中。

MD5 可以将任意长度的原文生成一个128位（16字节）的哈希值
SHA-1可以将任意长度的原文生成一个160位（20字节）的哈希值

1.2.3.2 对称密码

对称密码应用了相同的加密密钥和解密密钥。对称密码分为：序列密码(流密码)，分组密码(块密码)两种。流密码是对信息流中的每一个元素（一个字母或一个比特）作为基本的处理单元进行加密，块密码是先对信息流分块，再对每一块分别加密。

例如原文为1234567890，流加密即先对1进行加密，再对2进行加密，再对3进行加密……最后拼接成密文；块加密先分成不同的块，如1234成块，5678成块，90XX(XX为补位数字)成块，再分别对不同块进行加密，最后拼接成密文。前文提到的古典密码学加密方法，都属于流加密。

1.2.3.3 非对称密码

对称密码的密钥安全极其重要，加密者和解密者需要提前协商密钥，并各自确保密钥的安全性，一但密钥泄露，即使算法是安全的也无法保障原文信息的私密性。

在实际的使用中，远程的提前协商密钥不容易实现，即使协商好，在远程传输过程中也容易被他人获取，因此非对称密钥此时就凸显出了优势。

非对称密码有两支密钥，公钥（publickey）和私钥（privatekey），加密和解密运算使用的密钥不同。用公钥对原文进行加密后，需要由私钥进行解密；用私钥对原文进行加密后（此时一般称为签名），需要由公钥进行解密（此时一般称为验签）。公钥可以公开的，大家使用公钥对信息进行加密，再发送给私钥的持有者，私钥持有者使用私钥对信息进行解密，获得信息原文。因为私钥只有单一人持有，因此不用担心被他人解密获取信息原文。

1.2.4 如何设置密码才安全

密码不要太常见，不要使用类似于123456式的常用密码。
各应用软件密码建议不同，避免出现一个应用数据库被脱库，全部应用密码崩塌，
在设置密码的时候可以加一些特殊的标记（可在设置密码时增加注册时间、注册地点、应用特性等方法。例如tianjin123456，表示在天津注册的该应用。）

1.2.5 ASCII编码

ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。它是现今最通用的单字节编码系统，并等同于国际标准ISO/IEC 646。

字符转换成ASCII码

public class AsciiDemo {
    public static void main(String[] args) {
        char a='A';
        int b=a;
        System.out.println(a);
        System.out.println(b);
    }
}

字符串转换成ASCII码

public class AsciiDemo {
    public static void main(String[] args) {
        String s="Hello word";
        char[] chars = s.toCharArray();
        for(char c:chars){
            System.out.print(c+"\t");
        }
    }
}

1.3 凯撒加密

1.3.1 中国古代加密

看一个小故事，看看古人如何加密和解密：
公元683年，唐中宗即位。随后，武则天废唐中宗，立第四子李旦为皇帝，但朝政大事均由她自己专断。裴炎、徐敬业和骆宾王等人对此非常不满。徐敬业聚兵十万，在江苏扬州起兵。裴炎做内应，欲以拆字手段为其传递秘密信息。后因有人告密，裴炎被捕，未发出的密信落到武则天手中。这封密信上只有“青鹅”二字，群臣对此大惑不解。

武则天破解了“青鹅”的秘密：“青”字拆开来就是“十二月”，而“鹅”字拆开来就是“我自与”。密信的意思是让徐敬业、骆宾王等率兵于十二月进发，裴炎在内部接应。“青鹅”破译后，裴炎被杀。接着，武则天派兵击败了徐敬业和骆宾王。

1.3.2 外国加密

在密码学中，恺撒密码是一种最简单且最广为人知的加密技术。

凯撒密码最早由古罗马军事统帅盖乌斯·尤利乌斯·凯撒在军队中用来传递加密信息，故称凯撒密码。这是一种位移加密方式，只对26个字母进行位移替换加密，规则简单，容易破解。下面是位移1次的对比：

将明文字母表向后移动1位，A变成了B，B变成了C……，Z变成了A。同理，若将明文字母表向后移动3位：
则A变成了D，B变成了E……，Z变成了C。
字母表最多可以移动25位。凯撒密码的明文字母表向后或向前移动都是可以的，通常表述为向后移动，如果要向前移动1位，则等同于向后移动25位，位移选择为25即可。

它是一种替换加密的技术，明文中的所有字母都在字母表上向后（或向前）按照一个固定数目进行偏移后被替换成密文。

例如，当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。
这个加密方法是以恺撒的名字命名的，当年恺撒曾用此方法与其将军们进行联系。
恺撒密码通常被作为其他更复杂的加密方法中的一个步骤。

简单来说就是当秘钥为n，其中一个待加密字符ch，加密之后的字符为ch+n，当ch+n超过’z’时，回到’a’计数。

1.3.3 凯撒加密解密

package com.atguigu.kaiser;

public class KaiserDemo {
    public static void main(String[] args) {
        String input="hello word";
        int k=3;
        String s = encryptKaiser(input, k);
        System.out.println("加密"+s);
        String s1 = decryptKaiser(s, k);
        System.out.println("解密"+s1);
    }

    /**
     * 凯撒加密
     * @param s 明文
     * @param k 密钥
     */
    private static String encryptKaiser(String s, int k) {
        StringBuilder stringBuilder = new StringBuilder();
        new StringBuffer();
        char[] chars = s.toCharArray();
        for (char c : chars) {
            int b = c+k;
            stringBuilder.append((char)b);
        }
        return stringBuilder.toString();
    }

    /**
     * 凯撒解密
     * @param s 密文
     * @param k 密钥
     * @return
     */
    private static String decryptKaiser(String s,int k){
        StringBuilder stringBuilder = new StringBuilder();
        char[] chars = s.toCharArray();
        for (char c : chars) {
            int b=c - k;
            stringBuilder.append((char)b);
        }
        return stringBuilder.toString();
    }
}

1.4 频度分析法破解恺撒加密

密码棒

公元前5世纪的时候，斯巴达人利用一根木棒，缠绕上皮革或者羊皮纸，在上面横向写下信息，解下这条皮带。展开来看，这长串字母没有任何意义。

比如这样：
信差可以将这条皮带当成腰带，系在腰上。

比如这样
然后收件人将这条皮带缠绕在相同的木棒上，就能恢复信息了。

前404年，一位遍体鳞伤的信差来到斯巴达将领利桑德面前，这趟波斯之旅只有他和四位同伴幸存，利桑德接下腰带，缠绕到他的密码棒上，得知波斯的发那巴祖斯准备侵袭他，多亏密码棒利桑德才能够预先防范，击退敌军。

频率分析解密法

密码棒是不是太简单了些？
加密者选择将组成信息的字母替代成别的字母，比如说将a写成1，这样就不能被解密者直接拿到信息了。

这难不倒解密者，以英文字母为例，为了确定每个英文字母的出现频率，分析一篇或者数篇普通的英文文章，英文字母出现频率最高的是e，接下来是t，然后是a……，然后检查要破解的密文，也将每个字母出现的频率整理出来，假设密文中出现频率最高的字母是j，那么就可能是e的替身，如果密码文中出现频率次高的但是P，那么可能是t的替身，以此类推便就能解开加密信息的内容。这就是频率分析法。

将明文字母的出现频率与密文字母的频率相比较的过程
通过分析每个符号出现的频率而轻易地破译代换式密码
在每种语言中，冗长的文章中的字母表现出一种可对之进行分辨的频率。
e是英语中最常用的字母，其出现频率为八分之一

拷贝资料里面的 Utils.java和 FrequencyAnalysis.java到项目的 com.atguigu.kaiser包下面 , article.txt拷贝到项目文件夹的根目录
Utils.java

package com.atguigu.kaiser;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;

public class Utils {
	
	public static void print(byte[] bytes) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < bytes.length; i++) {
			sb.append(bytes[i]).append(" ");
		}
		System.out.println(sb);
	}
	
	public static String file2String(String path) throws IOException {
		FileReader reader = new FileReader(new File(path));
		char[] buffer = new char[1024];
		int len = -1;
		StringBuffer sb = new StringBuffer();
		while ((len = reader.read(buffer)) != -1) {
			sb.append(buffer, 0, len);
		}
		return sb.toString();
	}
	
	public static void string2File(String data, String path){
		FileWriter writer = null;
		try {
			writer = new FileWriter(new File(path));
			writer.write(data);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if (writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}
	
	public static String inputStream2String(InputStream in) throws IOException {
		int len = -1;
		byte[] buffer = new byte[1024];
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		while((len = in.read(buffer)) != -1) {
			baos.write(buffer, 0, len);
		}
		baos.close();
		
		return baos.toString("UTF-8");
	}
	
	
}

FrequencyAnalysis

package com.atguigu.kaiser;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 频率分析法破解凯撒密码
 */
public class FrequencyAnalysis {
	//英文里出现次数最多的字符
	private static final char MAGIC_CHAR = 'e';
	//破解生成的最大文件数
	private static final int DE_MAX_FILE = 4;
	
	public static void main(String[] args) throws Exception {
		//测试1，统计字符个数
//		printCharCount("article.txt");
		
		//加密文件
//		int key = 3;
//		encryptFile("article.txt", "article_en.txt", key);
//		printCharCount("article_en.txt");
		
		//读取加密后的文件
	    String artile = Utils.file2String("article_en.txt");
//	    //解密（会生成多个备选文件）
	    decryptCaesarCode(artile, "article_de.txt");
	}
	
	public static void printCharCount(String path) throws IOException{
		String data = Utils.file2String(path);
		List<Entry<Character, Integer>> mapList = getMaxCountChar(data);
		for (Entry<Character, Integer> entry : mapList) {
			//输出前几位的统计信息
			System.out.println("字符'" + entry.getKey() + "'出现" + entry.getValue() + "次");
		}
	}
	
	public static void encryptFile(String srcFile, String destFile, int key) throws IOException {
		String artile = Utils.file2String(srcFile);
		//加密文件
		String encryptData = KaiserDemo.encrypt(artile, key);
		//保存加密后的文件
		Utils.string2File(encryptData, destFile);
	}
	
	/**
	 * 破解凯撒密码
	 * @param input 数据源
	 * @return 返回解密后的数据
	 */
	public static void decryptCaesarCode(String input, String destPath) {
		int deCount = 0;//当前解密生成的备选文件数
		//获取出现频率最高的字符信息（出现次数越多越靠前）
		List<Entry<Character, Integer>> mapList = getMaxCountChar(input);
		for (Entry<Character, Integer> entry : mapList) {
			//限制解密文件备选数
			if (deCount >= DE_MAX_FILE) {
				break;
			}
			
			//输出前几位的统计信息
			System.out.println("字符'" + entry.getKey() + "'出现" + entry.getValue() + "次");
			
			++deCount;
			//出现次数最高的字符跟MAGIC_CHAR的偏移量即为秘钥
			int key = entry.getKey() - MAGIC_CHAR;
			System.out.println("猜测key = " + key + "， 解密生成第" + deCount + "个备选文件" + "\n");
			String decrypt = KaiserDemo.decrypt(input, key);
			
			String fileName = "de_" + deCount + destPath;
			Utils.string2File(decrypt, fileName);
		}
	}
	
	//统计String里出现最多的字符
	public static List<Entry<Character, Integer>> getMaxCountChar(String data) {
		Map<Character, Integer> map = new HashMap<Character, Integer>();
		char[] array = data.toCharArray();
		for (char c : array) {
			if(!map.containsKey(c)) {
				map.put(c, 1);
			}else{
				Integer count = map.get(c);
				map.put(c, count + 1);
			}
		}
		
		//输出统计信息
		/*for (Entry<Character, Integer> entry : map.entrySet()) {
			System.out.println(entry.getKey() + "出现" + entry.getValue() +  "次");
		}*/
		
		//获取获取最大值
		int maxCount = 0;
		for (Entry<Character, Integer> entry : map.entrySet()) {
			//不统计空格
			if (/*entry.getKey() != ' ' && */entry.getValue() > maxCount) { 
				maxCount = entry.getValue();
			}
		}
		
		//map转换成list便于排序
		List<Entry<Character, Integer>> mapList = new ArrayList<Entry<Character,Integer>>(map.entrySet());
		//根据字符出现次数排序
		Collections.sort(mapList, new Comparator<Entry<Character, Integer>>(){

			public int compare(Entry<Character, Integer> o1,
					Entry<Character, Integer> o2) {
				return o2.getValue().compareTo(o1.getValue());
			}
		});
		return mapList;
	}
}

主程序

	public static void main(String[] args) throws Exception {
		//测试1，统计字符个数
//		printCharCount("article.txt");
		
		//加密文件
//		int key = 3;
//		encryptFile("article.txt", "article_en.txt", key);
//		printCharCount("article_en.txt");
		
		//读取加密后的文件
	    String artile = Utils.file2String("article_en.txt");
//	    //解密（会生成多个备选文件）
	    decryptCaesarCode(artile, "article_de.txt");
	}

运行结果 # 出现次数最多，我们知道在英文当中 e 出现的频率是最高的，我们假设现在 # 号，就是 e ，变形而来的，我们可以对照 ascii 编码表，我们的凯撒加密当中位移是加了一个 key ，所以我们猜测两个值直接相差 -66 ，我们现在就以 -66 进行解密生成一个文件，我们查看第一个文件发现，根本读不懂，所以解密失败，我们在猜测 h 是 e ，h 和 e 之间相差3 ，所以我们在去看第二个解密文件，发现我们可以读懂，解密成功

1.5 Byte与bit

Byte : 字节. 数据存储的基本单位，比如移动硬盘1T ，单位是byte

bit : 比特, 又叫位. 一个位要么是0要么是1. 数据传输的单位 , 比如家里的宽带100MB，下载速度并没有达到100MB，一般都是12-13MB，那么是因为需要使用 100 / 8

关系: 1Byte = 8bit

package com.atguigu.ascii;

public class ByteBit {
    public static void main(String[] args) {
        String a= "hello word";
        byte[] bytes = a.getBytes();
        for(byte b:bytes){
            int c= b;
            //打印byte实际上就是ASCII码
            System.out.println(c);
            //byte对应的bit
            String s = Integer.toBinaryString(c);
            System.out.println(s);
        }
    }
}

1.6 常见加密方式

加密和解密是否使用同一把密钥可以分为对称加密和非对称加密
对称加密可以分成流加密和块加密

例如对123456789进行加密，流加密先加密1在加密2，在加密3.。。。。，块加密先加密1234 在加密5678相当于分组加密

1.6.1 对称加密

采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。
示例
- 我们现在有一个原文3要发送给B
- 设置密钥为108, 3 * 108 = 324, 将324作为密文发送给B
- B拿到密文324后, 使用324/108 = 3 得到原文
常见加密算法
- DES : Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。
- AES : Advanced Encryption Standard, 高级加密标准 .在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。
特点
- 加密速度快, 可以加密大文件
- 密文可逆, 一旦密钥文件泄漏, 就会导致数据暴露
- 加密后编码表找不到对应字符, 出现乱码
- 一般结合Base64使用，解决乱码的问题

1.6.2 DES加解密

package com.atguigu.desaes;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.DES;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;


/**
 * 对称加密
 */
public class DesAesDemo {
    public static void main(String[] args) throws Exception{
        //原文
        String input = "硅谷";
        //定义key
        //使用DES加密 密钥必须8个字节
        String key = "12345678";
        //算法
        String transformation = "DES";
        //加密类型
        String algorithm="DES";
        String encryptDes = encryptDes(input, key, transformation, algorithm);

        String encryptDes1 = encryptDes1(input, key);

        String encryptDes2 = encryptDes2(input, key);


        System.out.println(encryptDes);
        System.out.println(encryptDes1);
        System.out.println(encryptDes2);
        System.out.println(encryptDes.equals(encryptDes1));
        System.out.println(encryptDes.equals(encryptDes2));

        String decryptDes = decryptDes(encryptDes, key, transformation, algorithm);
        System.out.println(decryptDes);
        System.out.println(dncryptDes1(encryptDes, key));
        System.out.println(dncryptDes2(encryptDes, key));

    }

    /**
     * dec解密
     * @param encode 密文
     * @param key 密钥
     * @param transformation 加密算法
     * @param algorithm 加密类型
     * @return
     */
    private static String decryptDes(String encode, String key, String transformation, String algorithm) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, Base64DecodingException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        /**
         * 参数1. 模式(解密)
         * 参数2. 规则
         */
        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec);
        byte[] secret = Base64.decode(encode);
        byte[] bytes = cipher.doFinal(secret);
        return new String(bytes);
    }

    /**
     * hutool进行des加密方式二
     * @param input
     * @param key
     * @return
     */
    private static String encryptDes2(String input, String key) {
        DES des = SecureUtil.des(key.getBytes());
        byte[] encrypt = des.encrypt(input);
        return Base64.encode(encrypt);
    }

    /**
     * hutool进行des加密方式一
     * @param input
     * @param key
     * @return
     */
    private static String encryptDes1(String input, String key) {
        SymmetricCrypto asc = new SymmetricCrypto(SymmetricAlgorithm.DES, key.getBytes());
        byte[] encrypt = asc.encrypt(input);
        String encode = Base64.encode(encrypt);
        return encode;
    }

    /**
     * 原始的Des加密
     * @param input
     * @param key
     * @param transformation
     * @param algorithm
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    private static String encryptDes(String input, String key, String transformation, String algorithm) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        //创建加密对象
        Cipher cipher = Cipher.getInstance(transformation);
        //创建加密规则
        //第一个参数：表示key的字节
        //第二个参数：表示加密的类型
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        //进行加密初始化
        //第一个参数表示模式 加密模式 解密模式
        //第二个参数表示加密的规则
        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
        //调用加密方法
        //参数表示原文的字节数值
        byte[] bytes = cipher.doFinal(input.getBytes());
        return Base64.encode(bytes);
    }

    /**
     * hutool进行des解密方式二
     * @param input
     * @param key
     * @return
     */
    private static String dncryptDes2(String input, String key) throws Base64DecodingException {
        DES des = SecureUtil.des(key.getBytes());
        byte[] decode = Base64.decode(input);
        String s = des.decryptStr(decode);
        return s;
    }

    /**
     * hutool进行des解密方式一
     * @param input
     * @param key
     * @return
     */
    private static String dncryptDes1(String input, String key) throws Base64DecodingException {
        byte[] bytes = Base64.decode(input);
        SymmetricCrypto des = new SymmetricCrypto(SymmetricAlgorithm.DES, key.getBytes());
        return des.decryptStr(bytes);
    }
}

1.7 base64

Base64不是加密算法，是可读性算法

Base64是网络上最常见的用于传输8bit字节码的可读性编码算法之一
可读性编码算法不是为了保护数据的安全性，而是为了可读性
可读性编码不改变信息内容，只改变信息内容的表现形式

所谓Base64，即是说在编码过程中使用了64种字符：大写A到Z、小写a到z、数字0到9、“+”和“/”
Base58是Bitcoin(比特币)中使用的一种编码方式，主要用于产生Bitcoin的钱包地址
相比Base64，Base58不使用数字"0"，字母大写"O"，字母大写"I"，和字母小写"i"，以及"+“和”/"符号

算法原理
Base64 算法原理

base64 是3个字节为一组，一个字节 8位，一共就是24位，然后，把3个字节转成4组，每组6位，3×8=4×6

3 * 8 = 4 * 6 = 24 ，每组6位（然后扩展为8位1B），缺少的2位，会在高位进行补0 ，这样做的好处在于，base取的是后面6位，去掉高2位，那么base64的取值就可以控制在0-63位了，所以就叫base64，111 111 = 32 + 16 + 8 + 4 + 2 + 1 =63

base64 构成原则

小写 a - z = 26个字母
大写 A - Z = 26个字母
数字 0 - 9 = 10 个数字
+/ = 2个符号

大家可能发现一个问题，咱们的base64有个 = 号，但是在映射表里面没有发现 = 号，这个地方需要注意，等号非常特殊，因为base64是三个字节一组，如果当我们的位数不够的时候，会使用等号来补齐
在这里插入图片描述
等号测试

    public static void main(String[] args) {
        System.out.println(Base64.encode("1".getBytes()));
        System.out.println(Base64.encode("12".getBytes()));
        System.out.println(Base64.encode("123".getBytes()));
        // 硅谷:中文占6个字节，6 * 8 = 48 ，刚刚好被整除，所以没有等号 //UTF-8 是3B
        System.out.println(Base64.encode("硅谷".getBytes()));
    }

toString与new String的区别

    public static void main(String[] args) {
            String str="TU0jV0xBTiNVYys5bEdiUjZlNU45aHJ0bTdDQStBPT0jNjQ2NDY1Njk4IzM5OTkwMDAwMzAwMA==";

            String rlt1=new String(Base64.decode(str));//MM#WLAN#Uc+9lGbR6e5N9hrtm7CA+A==#646465698#399900003000

            String rlt2=Base64.decode(str).toString();//[B@1540e19d

            System.out.println(rlt1);
            System.out.println(rlt2);

    }

结果

MM#WLAN#Uc+9lGbR6e5N9hrtm7CA+A==#646465698#399900003000

[B@1540e19d

哪一个是正确的？为什么？

这里应该用new String()的方法，因为Base64加解密是一种转换编码格式的原理

toString()与new String ()用法区别

str.toString是调用了这个object对象的类的toString方法。一般是返回这么一个String：[class name]@[hashCode]
new String(str)是根据parameter是一个字节数组，使用java虚拟机默认的编码格式，将这个字节数组decode为对应的字符。若虚拟机默认的编码格式是ISO-8859-1，按照ascii编码表即可得到字节对应的字符。

什么时候用什么方法呢？

new String()一般使用字符转码的时候,byte[]数组的时候
toString()对象打印的时候使用

1.8 AES加密

package com.atguigu.desaes;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.AES;
import cn.hutool.crypto.symmetric.DES;
import cn.hutool.crypto.symmetric.SymmetricAlgorithm;
import cn.hutool.crypto.symmetric.SymmetricCrypto;
import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;


/**
 * 对称加密
 */
public class AesDemo {
    public static void main(String[] args) throws Exception{
        //原文
        String input = "硅谷";
        //定义key
        //使用AES加密 密钥必须8个字节
        String key = "1234567812345678";
        //算法
        String transformation = "AES";
        //加密类型
        String algorithm="AES";
        String encryptDes = encryptAes(input, key, transformation, algorithm);

        String encryptDes1 = encryptAes1(input, key);

        String encryptDes2 = encryptAes2(input, key);


        System.out.println(encryptDes);
        System.out.println(encryptDes1);
        System.out.println(encryptDes2);
        System.out.println(encryptDes.equals(encryptDes1));
        System.out.println(encryptDes.equals(encryptDes2));

        String decryptDes = decryptAes(encryptDes, key, transformation, algorithm);
        System.out.println(decryptDes);
        System.out.println(dncryptAes1(encryptDes, key));
        System.out.println(dncryptAes2(encryptDes, key));

    }

    /**
     * dec解密
     * @param encode 密文
     * @param key 密钥
     * @param transformation 加密算法
     * @param algorithm 加密类型
     * @return
     */
    private static String decryptAes(String encode, String key, String transformation, String algorithm) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, Base64DecodingException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        /**
         * 参数1. 模式(解密)
         * 参数2. 规则
         */
        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec);
        byte[] secret = Base64.decode(encode);
        byte[] bytes = cipher.doFinal(secret);
        return new String(bytes);
    }

    /**
     * hutool进行des加密方式二
     * @param input
     * @param key
     * @return
     */
    private static String encryptAes2(String input, String key) {
        AES aes = SecureUtil.aes(key.getBytes());
        byte[] encrypt = aes.encrypt(input);
        return Base64.encode(encrypt);
    }

    /**
     * hutool进行aes加密方式一
     * @param input
     * @param key
     * @return
     */
    private static String encryptAes1(String input, String key) {
        SymmetricCrypto asc = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());
        byte[] encrypt = asc.encrypt(input);
        String encode = Base64.encode(encrypt);
        return encode;
    }

    /**
     * 原始的aes加密
     * @param input
     * @param key
     * @param transformation
     * @param algorithm
     * @return
     * @throws NoSuchAlgorithmException
     * @throws NoSuchPaddingException
     * @throws InvalidKeyException
     * @throws IllegalBlockSizeException
     * @throws BadPaddingException
     */
    private static String encryptAes(String input, String key, String transformation, String algorithm) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        //创建加密对象
        Cipher cipher = Cipher.getInstance(transformation);
        //创建加密规则
        //第一个参数：表示key的字节
        //第二个参数：表示加密的类型
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), algorithm);
        //进行加密初始化
        //第一个参数表示模式 加密模式 解密模式
        //第二个参数表示加密的规则
        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
        //调用加密方法
        //参数表示原文的字节数值
        byte[] bytes = cipher.doFinal(input.getBytes());
        return Base64.encode(bytes);
    }

    /**
     * hutool进行aes解密方式二
     * @param input
     * @param key
     * @return
     */
    private static String dncryptAes2(String input, String key) throws Base64DecodingException {
        AES aes = SecureUtil.aes(key.getBytes());
        byte[] decode = Base64.decode(input);
        String s = aes.decryptStr(decode);
        return s;
    }

    /**
     * hutool进行aes解密方式一
     * @param input
     * @param key
     * @return
     */
    private static String dncryptAes1(String input, String key) throws Base64DecodingException {
        byte[] bytes = Base64.decode(input);
        SymmetricCrypto aes = new SymmetricCrypto(SymmetricAlgorithm.AES, key.getBytes());
        return aes.decryptStr(bytes);
    }
}

1.9 加密模式

加密模式：https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html
前面DES和AES都有key，而加密模式是说怎么用key。
ECB是同key并行，CBC是变key串行

1.9.1 ECB

ECB : Electronic codebook, 电子密码本. 需要加密的消息按照块密码的块大小被分为数个块，并对每个块进行独立加密
但是每个块使用的是同一个key，所以可以并行处理

在这里插入图片描述

优点 : 可以并行处理数据
缺点 : 同样的原文生成同样的密文, 不能很好的保护数据
同时加密，原文是一样的，加密出来的密文也是一样的

1.9.2 CBC

CBC : Cipher-block chaining, 密码块链接. 每个明文块先与前一个密文块进行异或后，再进行加密。在这种方法中，每个密文块都依赖于它前面的所有明文块

在加密的时候，会取决于前面的iv相邻，把前面的相邻进行异或处理，后面的铭文进行加密的时候，会一直依赖于前面的加密key

在这里插入图片描述

优点 : 同样的原文生成的密文不一样
缺点 : 串行处理数据
注意CBC传参的时候不只要key，还要有一个IV向量

1.9.3 加密模式总结

前面DES和AES都有key，而加密模式是说怎么用key。

ECB是同key并行，CBC是变key串行

1.9.4 加密模式的使用

如前面的代码中，只要写成String transformation = “DES/CBC/NoPadding”;即可

另外在CBC中还要在加密解密中都写好IV向量IvParameterSpec iv = new IvParameterSpec(key.getBytes());

IV这个字节数组可以自己定，但必须是8个字节

public class DesAesDemo {
    public static void main(String[] args) throws Exception{
        // 原文 如果使用的是不填充的模式，那么原文必须是8个字节的整数倍
        String input = "硅谷12";
        // 定义key
        // 如果使用des进行加密，那么密钥必须是8个字节
        String key = "12345678";
        // 算法 qANksk5lvqM=
//        String transformation = "DES";
        // ECB:表示加密模式
        // PKCS5Padding:表示填充模式 qANksk5lvqM=
//        String transformation = "DES/ECB/PKCS5Padding";
        // 如果默认情况，没有写填充模式和加密模式，那么默认就使用DES/ECB/PKCS5Padding
//        8Ze/OtPlSaU=
//        String transformation = "DES/CBC/PKCS5Padding";
        //Y6htKI/ceJg=
        String transformation = "DES/CBC/NoPadding";
        // 加密类型
        String algorithm = "DES";
        // 指定获取密钥的算法
        String encryptDES = encryptDES(input, key, transformation, algorithm);
        System.out.println("加密:" + encryptDES);

        String s = decryptDES(encryptDES, key, transformation, algorithm);
        System.out.println("解密:" + s);
    }

    /**
     * 解密
     * @param encryptDES  密文
     * @param key         密钥
     * @param transformation 加密算法
     * @param algorithm   加密类型
     * @return
     */
    private static String decryptDES(String encryptDES, String key, String transformation, String algorithm) throws Exception{
        Cipher cipher = Cipher.getInstance(transformation);
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(),algorithm);
        // 创建iv向量 //CBC加密模式需要有IV向量
        IvParameterSpec iv = new IvParameterSpec(key.getBytes());
        //Cipher.DECRYPT_MODE:表示解密
        // 解密规则
        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec,iv);
        // 解密，传入密文
        byte[] bytes = cipher.doFinal(Base64.decode(encryptDES));

        return new String(bytes);
    }

    /**
     * 使用DES加密数据
     *
     * @param input          : 原文
     * @param key            : 密钥(DES,密钥的长度必须是8个字节)
     * @param transformation : 获取Cipher对象的算法
     * @param algorithm      : 获取密钥的算法
     * @return : 密文
     * @throws Exception
     */
    private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
        // 获取加密对象
        Cipher cipher = Cipher.getInstance(transformation);
        // 创建加密规则
        // 第一个参数key的字节
        // 第二个参数表示加密算法
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
        // 创建iv向量，iv向量，是使用到CBC加密模式
        // 在使用iv向量进行加密的时候，iv的字节也必须是8个字节
        IvParameterSpec iv = new IvParameterSpec("12345678".getBytes());
        // ENCRYPT_MODE：加密模式
        // DECRYPT_MODE: 解密模式
        // 初始化加密模式和算法
        cipher.init(Cipher.ENCRYPT_MODE,sks,iv);
        // 加密
        byte[] bytes = cipher.doFinal(input.getBytes());

        // 输出加密后的数据
        String encode = Base64.encode(bytes);

        return encode;
    }
}

1.10 填充模式

当需要按块处理的数据, 数据长度不符合块处理需求时, 按照一定的方法填充满块长的规则
使用方法：和加密模式一样，写在String transformation = “DES/CBC/NoPadding”;
但要注意DES和AES的限制，不能不是8/16字节的整数倍
iv字节也必须是8个字节

NoPadding

不填充.
在DES加密算法下, 要求原文长度必须是8byte的整数倍
在AES加密算法下, 要求原文长度必须是16byte的整数倍

PKCS5Padding

数据块的大小为8位, 不够就补足

Tips

默认情况下, 加密模式和填充模式为 : ECB/PKCS5Padding
如果使用CBC模式, 在初始化Cipher对象时, 需要增加参数, 初始化向量IV : IvParameterSpec iv = new IvParameterSpec(key.getBytes());

加密模式和填充模式

AES/CBC/NoPadding (128)
AES/CBC/PKCS5Padding (128)
AES/ECB/NoPadding (128)
AES/ECB/PKCS5Padding (128)
DES/CBC/NoPadding (56)
DES/CBC/PKCS5Padding (56)
DES/ECB/NoPadding (56)
DES/ECB/PKCS5Padding (56)
DESede/CBC/NoPadding (168)
DESede/CBC/PKCS5Padding (168)
DESede/ECB/NoPadding (168)
DESede/ECB/PKCS5Padding (168)
RSA/ECB/PKCS1Padding (1024, 2048)
RSA/ECB/OAEPWithSHA-1AndMGF1Padding (1024, 2048)
RSA/ECB/OAEPWithSHA-256AndMGF1Padding (1024, 2048)

1.11 消息摘要

消息摘要（Message Digest）又称为数字摘要(Digital Digest)它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生
输入长度不定，输出长度一定。单向不可逆
使用数字摘要生成的值是不可以篡改的，为了保证文件或者值的安全

1.11.1 特点

无论输入的消息有多长，计算出来的消息摘要的长度总是固定的。例如应用MD5算法摘要的消息有128个比特位，用SHA-1算法摘要的消息最终有160比特位的输出
只要输入的消息不同，对其进行摘要以后产生的摘要消息也必不相同；但相同的输入必会产生相同的输出
消息摘要是单向、不可逆的

常见算法 :

MD5
SHA1
SHA256
SHA512

在线获取消息摘要

比如有的网站下载软件有sha256等值，可以下载该软件，然后得到其消息摘要，比对官网的消息摘要，就知道该软件有没有被修改过

百度搜索 tomcat ，进入官网下载，会经常发现有 sha1，sha512 , 这些都是数字摘要

1.11.2 MD5算法的实现

import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.digest.MD5;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class DigestDemo1 {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        //原文
        String input = "aa";
        //算法
        String algorithm="Md5";
        //常见消息摘要对象
        MessageDigest digest = MessageDigest.getInstance(algorithm);
        //执行消息摘要算法
        byte[] digest1 = digest.digest(input.getBytes());
        String encode = Base64.encode(digest1);
        System.out.println(encode);

        //hutool工具类实现
        byte[] digest2 = MD5.create().digest(input);
        String encode1 = Base64.encode(digest2);
        System.out.println(encode1);
        System.out.println(encode.equals(encode1));
        
    }
}

1.11.2其他数字摘要算法

package com.atguigu.digest;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class DigestDemo1 {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        //原文
        String input = "aa";
        //算法
        String algorithm="MD5";
        String digest = getDigest(input, algorithm);
        System.out.println("MD5:"+digest);
        String sha1 = getDigest(input, "SHA-1");
        System.out.println("SHA-1:"+sha1);
        String sha256 = getDigest(input, "SHA-256");
        System.out.println("SHA-256:"+sha256);
        String sha512 = getDigest(input, "SHA-512");
        System.out.println("SHA-512:"+sha512);
    }

    /**
     * 获取数字摘要
     * @param input 原文
     * @param algorithm 算法
     * @return
     * @throws NoSuchAlgorithmException
     */
    private static String getDigest(String input, String algorithm) throws NoSuchAlgorithmException {
        //创建消息摘要对象
        MessageDigest digest = MessageDigest.getInstance(algorithm);
        //执行消息摘要算法
        byte[] digest1 = digest.digest(input.getBytes());
        return toHex(digest1);
    }

    private static String toHex(byte[] digest){
        StringBuffer sb = new StringBuffer();
        //对密文进行迭代
        for(byte b:digest){
            //把密文转成16进制
            String s = Integer.toHexString(b & 0xff);
            //如果密文的长度为1 需要在高位进行补0
            if(s.length() == 1){
                s = "0"+s;
            }
            sb.append(s);
        }
        return sb.toString();
    }
}

1.12 非对称加密

简介：

非对称加密算法又称现代加密算法。
非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。
与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey)
公开密钥和私有密钥是一对
如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。
如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。
因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

示例

首先生成密钥对, 公钥为(5,14), 私钥为(11,14)
现在A希望将原文2发送给B
A使用公钥加密数据， 2的5次方mod 14 = 4 , 将密文4发送给B
B使用私钥解密数据， 4的11次方mod14 = 2, 得到原文2

特点

加密和解密使用不同的密钥
如果使用私钥加密, 只能使用公钥解密
如果使用公钥加密, 只能使用私钥解密
处理数据的速度较慢, 因为安全级别高

常见算法

RSA
ECC

1.12.1 生成公钥和私钥

生成RSA的公钥私钥：KeyPairGenerator类

package com.atguigu.rsa;

import cn.hutool.core.util.HexUtil;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import java.security.*;

public class RsaDemo {

    public static void main(String[] args) throws Exception {
       //创建密钥对
       String algorithm = "RSA";
       //KeyPairGenerator生成密钥对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        //生成公钥
        PublicKey publicKey = keyPair.getPublic();
        //获取私钥的字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        //获取公钥的字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        //进行base64编码
        String privateKeyEncodeString = Base64.encode(privateKeyEncoded);
        String publicKeyEncodeString = Base64.encode(publicKeyEncoded);
        System.out.println(privateKeyEncodeString);
        System.out.println(publicKeyEncodeString);
    }
}

1.12.2 私钥加密

package com.atguigu.rsa;

import cn.hutool.core.util.HexUtil;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import java.security.*;

public class RsaDemo {

    public static void main(String[] args) throws Exception {
        String input ="硅谷";
       //创建密钥对
       String algorithm = "RSA";
       //KeyPairGenerator生成密钥对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        //生成公钥
        PublicKey publicKey = keyPair.getPublic();
        //获取私钥的字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        //获取公钥的字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        //进行base64编码
        String privateKeyEncodeString = Base64.encode(privateKeyEncoded);
        String publicKeyEncodeString = Base64.encode(publicKeyEncoded);
//        System.out.println(privateKeyEncodeString);
//        System.out.println(publicKeyEncodeString);

        //创建加密对象
        Cipher cipher = Cipher.getInstance("RSA");
        //对加密对象进行初始化
        //第一个参数：加密的模式
        //第二个参数：使用公钥加密还是私钥加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        //使用私钥进行加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        System.out.println(Base64.encode(bytes));
    }
}

1.12.3 私钥加密公钥解密

package com.atguigu.rsa;

import cn.hutool.core.util.HexUtil;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import java.security.*;

public class RsaDemo {

    public static void main(String[] args) throws Exception {
        String input ="硅谷";
       //创建密钥对
       String algorithm = "RSA";
       //KeyPairGenerator生成密钥对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        //生成公钥
        PublicKey publicKey = keyPair.getPublic();
        //获取私钥的字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        //获取公钥的字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        //进行base64编码
        String privateKeyEncodeString = Base64.encode(privateKeyEncoded);
        String publicKeyEncodeString = Base64.encode(publicKeyEncoded);
//        System.out.println(privateKeyEncodeString);
//        System.out.println(publicKeyEncodeString);

        //创建加密对象
        Cipher cipher = Cipher.getInstance("RSA");
        //对加密对象进行初始化
        //第一个参数：加密的模式
        //第二个参数：使用公钥加密还是私钥加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        //使用私钥进行加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        System.out.println(Base64.encode(bytes));

        //私钥解密
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] bytes1 = cipher.doFinal(bytes);
        System.out.println(bytes1.toString());
        System.out.println(new String(bytes1));
    }
}

注意：只能私钥加密公钥进行解密

1.12.4 加密解密方法的提取

package com.atguigu.rsa;

import cn.hutool.core.util.HexUtil;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;

public class RsaDemo {

    public static void main(String[] args) throws Exception {
        String input ="硅谷";
       //创建密钥对
       String algorithm = "RSA";
       //KeyPairGenerator生成密钥对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        //生成公钥
        PublicKey publicKey = keyPair.getPublic();
        String s = encryptRSA(algorithm, privateKey, input);
        System.out.println(s);
        String s1 = decryptRSA(algorithm, publicKey, s);
        System.out.println(s1);
    }

    /**
     * 使用密钥加密数据
     * @param algorithm 算法
     * @param privateKey 密钥
     * @param input  原文
     * @return 密文
     * @throws Exception
     */
    public static String encryptRSA(String algorithm,Key privateKey,String input) throws Exception{
        //创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        //对加密对象进行初始化
        //第一个参数：加密的模式
        //第二个参数：使用公钥加密还是私钥加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        //使用私钥进行加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        return Base64.encode(bytes);
    }

    /**
     * 解密数据
     * @param algorithm 算法
     * @param publicKey 密钥
     * @param encrypted 密文
     * @return 原文
     * @throws Exception
     */
    public static String decryptRSA(String algorithm,Key publicKey,String encrypted) throws Exception{
        //创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] decode = Base64.decode(encrypted);
        byte[] bytes1 = cipher.doFinal(decode);
        return new String(bytes1);
    }
}

1.12.5 读取公钥和私钥

package com.atguigu.rsa;

import cn.hutool.core.util.HexUtil;
import com.sun.org.apache.xml.internal.security.exceptions.Base64DecodingException;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RsaDemo {

    public static void main(String[] args) throws Exception {
        String input ="硅谷";
       //创建密钥对
       String algorithm = "RSA";
//       generateKeyToFile(algorithm,"a.pub","a.pri");
       //读取私钥
        PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
        PublicKey publicKey = getPublicKey("a.pub", algorithm);
        String encryptRSA = encryptRSA(algorithm, privateKey, input);
        System.out.println(encryptRSA);
        String decryptRSA = decryptRSA(algorithm, publicKey, encryptRSA);
        System.out.println(decryptRSA);
    }


    private static PublicKey getPublicKey(String publicPath, String algorithm) throws Exception {
        String publicKeyString = FileUtils.readFileToString(new File(publicPath),Charset.defaultCharset());
        //创建key的工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        //创建公钥规则
        X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
        return keyFactory.generatePublic(spec);

    }

    /**
     * 读取私钥
     * @param priPath 私钥的路径
     * @param algorithm 算法
     * @return
     */
    private static PrivateKey getPrivateKey(String priPath, String algorithm) throws Exception {
        String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
        //创建key 的工厂
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        //创建私钥规则
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
        //发挥私钥对象
        return keyFactory.generatePrivate(keySpec);
    }

    /**
     * 使用密钥加密数据
     * @param algorithm 算法
     * @param privateKey 密钥
     * @param input  原文
     * @return 密文
     * @throws Exception
     */
    public static String encryptRSA(String algorithm,Key privateKey,String input) throws Exception{
        //创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        //对加密对象进行初始化
        //第一个参数：加密的模式
        //第二个参数：使用公钥加密还是私钥加密
        cipher.init(Cipher.ENCRYPT_MODE,privateKey);
        //使用私钥进行加密
        byte[] bytes = cipher.doFinal(input.getBytes());
        return Base64.encode(bytes);
    }

    /**
     * 解密数据
     * @param algorithm 算法
     * @param publicKey 密钥
     * @param encrypted 密文
     * @return 原文
     * @throws Exception
     */
    public static String decryptRSA(String algorithm,Key publicKey,String encrypted) throws Exception{
        //创建加密对象
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] decode = Base64.decode(encrypted);
        byte[] bytes1 = cipher.doFinal(decode);
        return new String(bytes1);
    }

    /**
     * 保存公钥和私，把公钥和私钥保存到跟目录
     * @param algorithm 算法
     * @param pubPath 公钥路径
     * @param priPath 私钥路径
     */
    public static void generateKeyToFile(String algorithm,String pubPath,String priPath)throws Exception{
        //KeyPairGenerator生成密钥对象
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //生成私钥
        PrivateKey privateKey = keyPair.getPrivate();
        //生成公钥
        PublicKey publicKey = keyPair.getPublic();
        //获取私钥的字节数组
        byte[] privateKeyEncoded = privateKey.getEncoded();
        //获取公钥的字节数组
        byte[] publicKeyEncoded = publicKey.getEncoded();
        //进行base64编码
        String privateKeyEncodeString = Base64.encode(privateKeyEncoded);
        String publicKeyEncodeString = Base64.encode(publicKeyEncoded);
        //把公钥和私钥保存到根目录
        FileUtils.writeStringToFile(new File(priPath),privateKeyEncodeString, Charset.forName("UTF-8"));
        FileUtils.writeStringToFile(new File(pubPath),publicKeyEncodeString, Charset.forName("UTF-8"));

    }
}

1.12.6 Hutool工具类实现RSA加解密

package com.atguigu.rsa;

import cn.hutool.crypto.asymmetric.KeyType;
import cn.hutool.crypto.asymmetric.RSA;
import java.util.Base64;

public class RasDemo1 {
    public static void main(String[] args) {
        RSA rsa = new RSA();
        String input ="硅谷";
        byte[] encrypt = rsa.encrypt(input.getBytes(), KeyType.PublicKey);
        System.out.println(Base64.getEncoder().encode(encrypt));
        byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
        System.out.println(new String(decrypt));
    }
}

1.13 数字签名

数字签名（又称公钥数字签名）是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。它是一种类似写在纸上的普通的物理签名，但是使用了公钥加密领域的技术来实现的，用于鉴别数字信息的方法。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。

数字签名是非对称密钥加密技术与数字摘要技术的应用。

1.13.1 简单认识

相信我们都写过信，在写信的时候落款处总是要留下自己的名字，用来表示写信的人是谁。我们签的这个字就是生活中的签名：

而数字签名呢？其实也是同样的道理，他的含义是：在网络中传输数据时候，给数据添加一个数字签名，表示是谁发的数据，而且还能证明数据没有被篡改。

OK，数字签名的主要作用就是保证了数据的有效性（验证是谁发的）和完整性（证明信息没有被篡改）。下面我们就来好好地看一下他的底层实现原理是什么样子的。

1.13.2 基本原理

为了理解得清楚，我们通过案例一步一步来讲解。话说张三有俩好哥们A、B。由于工作原因，张三和AB写邮件的时候为了安全都需要加密。于是张三想到了数字签名：

整个思路是这个样子的：

第一步：加密采用非对称加密，张三有三把钥匙，两把公钥，送给朋友。一把私钥留给自己。

第二步：A或者B写邮件给张三：A先用公钥对邮件加密，然后张三收到邮件之后使用私钥解密。

第三步：张三写邮件给A或者B：

（1）张三写完邮件，先用hash函数生成邮件的摘要，附着在文章上面，这就完成了数字签名，然后张三再使用私钥加密。就可以把邮件发出去了。
（2）A或者是B收到邮件之后，先把数字签名取下来，然后使用自己的公钥解密即可。这时候取下来的数字签名中的摘要若和张三的一致，那就认为是张三发来的，再对信件本身使用Hash函数，将得到的结果，与上一步得到的摘要进行对比。如果两者一致，就证明这封信未被修改过。
上面的流程我们使用一张图来演示一下：
在这里插入图片描述

服务器把内容（证书明文）经过hash算法得到证书的摘要，再经过私钥加密得到证书的数字签名，然后发送证书和数字签名给浏览器。

浏览器得到了证书和数字签名，先拿证书里的公钥对对数字签名解密得到摘要。再拿证书里的hash算法对证书进行hash得到摘要。对比连个摘要是否相同。如果相同，则代表证书没有被修改过，也就证明了是该服务器发过来的。

但是如果别人伪造了一个证书呢？比如证书里写的颁发给了baidu，而且公钥是第三者的，你发送的内容就被别人拦截下来用第三者的私钥解密，偷看后为了不被发现再用第三者的私钥加密发送给baidu。

为了验证证书没被篡改过，我们可以取认证中心鉴定。

1.13.3 数字证书

上面提到我们对签名进行验证时，需要用到公钥。如果公钥是伪造的，那我们无法验证数字签名了，也就根本不可能从数字签名确定对方的合法性了。这时候证书就闪亮登场了。我们可能都有考各种证书的经历，比如说普通话证书，四六级证书等等，但是归根结底，到任何场合我们都能拿出我们的证书来证明自己确实已经考过了普通话，考过了四六级。这里的证书也是同样的道理。

如果不理解证书的作用，我们可以举一个例子，比如说我们的毕业证书，任何公司都会承认。为什么会承认？因为那是国家发得，大家都信任国家。也就是说只要是国家的认证机构，我们都信任它是合法的。

服务器有公钥A，私钥A。认证机构有私钥B，公钥B
服务器把公钥A给认证机构，为了让认证中心给自己开个证明说我这个公钥确实是我的，而认证中心自己系统里也知道我给谁鉴定过以及他的公钥。
即使浏览器把公钥丢了也可以继续从证书里获取到

点击浏览器链接的左面，可以看到证书。

1.13.4 网页加密

我们看一个应用“数字证书”的实例：https协议。这个协议主要用于网页加密
首先，客户端向服务器发出加密请求。
服务器用自己的私钥加密网页以后，连同本身的数字证书，一起发送给客户端。
客户端（浏览器）的“证书管理器”，有“受信任的根证书颁发机构”列表。客户端会根据这张列表，查看解开数字证书的公钥是否在列表之内
如果数字证书记载的网址，与你正在浏览的网址不一致，就说明这张证书可能被冒用，浏览器会发出警告。
如果数字证书是可靠的，客户端就可以使用证书中的服务器公钥，对信息进行加密，然后与服务器交换加密信息。

1.13.5 代码实现

package com.atguigu;

import cn.hutool.crypto.asymmetric.RSA;
import com.sun.org.apache.xml.internal.security.utils.Base64;

import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;

public class SignatureDemo {
    public static void main(String[] args) throws Exception {
        String a ="123";
        RSA rsa = new RSA();
        PrivateKey privateKey = rsa.getPrivateKey();
        PublicKey publicKey = rsa.getPublicKey();
        //获取数字签名
        String signatureData = getSignature(a,"sha256withrsa",privateKey);
        System.out.println(signatureData);
        //校验签名
        boolean b = verifySignature(a,"sha256withrsa",publicKey,signatureData);
        System.out.println(b);
    }

    /**
     * 校验签名
     * @param input 原文
     * @param algorithm 算法
     * @param publicKey 公钥key
     * @param signatureData 签名密文
     * @return
     */
    private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signatureData) throws Exception {
        //获取前面对象
        Signature signature = Signature.getInstance(algorithm);
        //初始化校验
        signature.initVerify(publicKey);
        //传入原文
        signature.update(input.getBytes());
        //校验数据
        return signature.verify(Base64.decode(signatureData));

    }

    /**
     * 生成数字签名
     * @param input 原文
     * @param algorithm 算法
     * @param privateKey 密钥
     * @return
     */
    private static String getSignature(String input, String algorithm, PrivateKey privateKey) throws Exception{
        //获取前面对象
        Signature signature = Signature.getInstance(algorithm);
        //初始化签名
        signature.initSign(privateKey);
        //传入原文
        signature.update(input.getBytes());
        //开始签名
        byte[] sign = signature.sign();
        //开始base64编码
        return Base64.encode(sign);
    }
}

hutool工具类实现

package com.atguigu.signature;

import cn.hutool.core.codec.Base64;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.asymmetric.RSA;
import cn.hutool.crypto.asymmetric.Sign;
import cn.hutool.crypto.asymmetric.SignAlgorithm;
import cn.hutool.crypto.symmetric.AES;

public class SignatureDemo1 {
    public static void main(String[] args) {
        String input ="123";
        Sign sign = SecureUtil.sign(SignAlgorithm.SHA256withRSA);
        byte[] sign1 = sign.sign(input);
        System.out.println(new String(sign1));
        System.out.println(sign.verify(input.getBytes(), sign1));
        System.out.println("==================");
        RSA rsa = new RSA();
        Sign sign2 = SecureUtil.sign(SignAlgorithm.SHA256withRSA, rsa.getPrivateKeyBase64(), rsa.getPublicKeyBase64());
        byte[] sign3 = sign2.sign(input);
        System.out.println(new String(sign3));
        System.out.println(sign2.verify(input.getBytes(),sign3));
    }
}