Java基础29（编码算法 哈希算法 MD5 SHA—1 HMac 算法 堆成加密算法）

目录

一、编码算法

1. 常见编码

2. URL编码

3. Base64编码 

4. 小结

二、哈希算法

1. 哈希碰撞

2. 常用哈希算法

MD5算法

SHA-1算法 

自定义HashTools工具类

3. 哈希算法的用途

校验下载文件

 存储用户密码

4. 小结

三、Hmac算法

小结：

四、对称加密算法

1. 使用AES加密

ECB模式

一、编码算法

ASCII码就是一种编码，字母A的编码是十六进制的0x41，字母B是0x42，以此类推：

字母	ASCII编码
A	0x41
B	0x42
C	0x43
D	0x44
…	…

因为ASCII编码最多只能有127个字符，要想对更多的文字进行编码，就需要用占用2个字节的Unicode或者3个字节的UTF-8。例如：中文的”中”字使用Unicode编码就是0x4e2d，UTF-8编码是0xe4b8ad。

汉字	Unicode编码	UTF-8编码
中	0x4e2d	0xe4b8ad
文	0x6587	0xe69687
编	0x7f16	0xe7bc96
码	0x7801	0xe7a081

因此，最简单的编码是直接给每个字符指定一个若干字节表示的整数，复杂一点的编码就需要根据一个已有的编码推算出来。

1. 常见编码

ASCII码：ASCII码中只存储英文字符，有127个字符，占一个字节

Unicode码：可以存储中文，占两个字节

UTF-8：实际上是从Unicode码中推算出来的一种编码方式

URL编码：是浏览器发送数据时的一种编码，通常附加在URL的参数部分。之所以需要，是因为很多服务器只能识别ASCII字符，对字符进行编码，URL它独有一套自己的编码规则。在java的类库中提供了URLEncoder类，来对任意字符串进行URL编码。

如果服务器收到URL编码，会对它自动进行解码

Base64编码：对二进制数据进行编码，转换成文本格式，这样在很多文本中就可以处理进制数据。
Base64编明是种编码算法。不是加密算法。

2. URL编码

URL编码是浏览器发送数据给服务器时使用的编码，它通常附加在URL的参数部分，例如：

http://www.baidu.com/s?wd=%E4%B8%AD%E6%96%87

之所以需要URL编码，是因为出于兼容性考虑，很多服务器只识别ASCII字符。但如果URL中包含中文、日文这些非ASCII字符怎么办？不要紧，URL编码有一套规则：

• 如果字符是A~Z，a~z，0~9以及-、_、.、*，则保持不变；
• 如果是其他字符，先转换为UTF-8编码，然后对每个字节以%XX表示。

例如：字符”中”的UTF-8编码是0xe4b8ad，因此，它的URL编码是%E4%B8%AD。URL编码总是大写。
Java标准库提供了一个URLEncoder类来对任意字符串进行URL编码：

//URLEncoder，url编码操作
//URLDecoder类，url解码操作
public class Demo01 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		// 编码
		String keyWorld = "中文";
		String encodeString = URLEncoder.encode(keyWorld, "utf-8");
		System.out.println("编码：" + encodeString);//编码：%E4%B8%AD%E6%96%87

		
	}
}

如果服务器收到URL编码的字符串，就可以对其进行解码，还原成原始字符串。Java标准库的URLDecoder就可以解码：

// 解码
		String decodeString = URLDecoder.decode(encodeString, "utf-8");
		System.out.println(decodeString);//中文

要特别注意：URL编码是编码算法，不是加密算法。URL编码的目的是把任意文本数据编码为%前缀表示的文本，编码后的文本仅包含A~Z，a~z，0~9，-，_，.，*和%，便于浏览器和服务器处理。

//URL编码注意：
public class Demo02 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		//编码只对中文内容进行处理  
		String keyWorld = "特斯拉";
		String encodeString = URLEncoder.encode(keyWorld, "utf-8");
		String urlString = "http://www.baidu.com/s?wd=";
		System.out.println(urlString + encodeString);//http://www.baidu.com/s?wd=%E7%89%B9%E6%96%AF%E6%8B%89

		//解码操作，url可以对整个链接进行解码
		String decodeString = URLDecoder.decode(urlString + encodeString, "utf-8");
		System.out.println(decodeString);//http://www.baidu.com/s?wd=特斯拉

	}
}

3. Base64编码 

        URL编码是对字符进行编码，表示成%xx的形式，而Base64编码是对二进制数据进行编码，表示成文本格式。
        Base64编码可以把任意长度的二进制数据变为纯文本，并且纯文本内容中且只包含指定字符内容：A~Z、a~z、0~9、+、/、=。它的原理是把3字节的二进制数据按6bit一组，用4个int整数表示，然后查表，把int整数用索引对应到字符，得到编码后的字符串。
        6位整数的范围总是0~63，所以，能用64个字符表示：字符A~Z对应索引0~25，字符a~z对应索引26~51，字符0~9对应索引52~61，最后两个索引62、63分别用字符+和/表示。

        举个例子：3个byte数据分别是e4、b8、ad，按6bit分组得到十六进制39、0b、22和2d，分别对应十进制57、11、34、45，通过索引计算结果为5Lit4

在Java中，二进制数据就是byte[]数组。Java标准库提供了Base64来对byte[]数组进行编解码：

//Base64编码
//3字节信息一组，24-6位 4字符
public class Demo03 {
	public static void main(String[] args) {
		String string = "中";
		byte[] bytes = string.getBytes();
		// JDK1.8后才提供
		String encodeString = Base64.getEncoder().encodeToString(bytes);
		System.out.println(encodeString);// 5Lit

		// 解码
		byte[] decodeBytes = Base64.getDecoder().decode(encodeString);
		System.out.println(Arrays.toString(decodeBytes));// [-28, -72, -83]
		System.out.println(new String(decodeBytes));// 中
	}
}

将图片使用base64转成字符串并保存到a.txt中:

//将图片使用base64转成字符串并保存到a.txt中
//将a.txt中的信息使用base64解码，还原成图片写出
public class Demo04 {
	public static void main(String[] args) throws IOException {
		// 将一个图片进行编码，文件进行保存
		byte[] bytes = Files.readAllBytes(Paths.get("C:\Users\张柯堂\Desktop\头像.png"));
		String str = Base64.getEncoder().encodeToString(bytes);
		Files.write(Paths.get("a.txt"), str.getBytes());
		System.out.println("写出图片字符信息结束");

		// 解码
		// 读入信息
		byte[] readBytes = Files.readAllBytes(Paths.get("a.txt"));
		byte[] decodeBytes = Base64.getDecoder().decode(readBytes);
		Files.write(Paths.get("C:\Users\张柯堂\Desktop\copy.png"), decodeBytes);
		System.out.println("写出图片结束");

	}
}

因为标准的Base64编码会出现+、/和=，所以不适合把Base64编码后的字符串放到URL中。一种针对URL的Base64编码可以在URL中使用的Base64编码，它仅仅是把+变成-，/变成_：

public class Demo05 {
	public static void main(String[] args) {
		//+ /
		//	原始字节内
		byte[] input = new byte[] {2,-114,127,0};
		
		//使用两种编码方式对input转换/-->_ +-->-
		String str = Base64.getEncoder().encodeToString(input);
		String str1 = Base64.getUrlEncoder().encodeToString(input);
		System.out.println(str);//Ao5/AA==
		System.out.println(str1);//Ao5_AA==
		
		//解码操作
		byte[] byte1 =Base64.getDecoder().decode(str);
		byte[] byte2 =Base64.getUrlDecoder().decode(str1);
		
		//输出解码后的内容
		System.out.println(Arrays.toString(byte1));//[2, -114, 127, 0]
		System.out.println(Arrays.toString(byte2));//[2, -114, 127, 0]
		
	}
}

4. 小结

• URL编码和Base64编码都是编码算法，它们不是加密算法；
• URL编码的目的是把任意文本数据编码为%前缀表示的文本，便于浏览器和服务器处理；
• Base64编码的目的是把任意二进制数据编码为文本，但编码后数据量会增加1/3。

二、哈希算法

哈希算法（Hash）又称摘要算法（Digest），它的作用是：对任意一组输入数据进行计算，得到一个固定长度的输出摘要。
哈希算法最重要的特点就是：

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

所以，哈希算法的目的：为了验证原始数据是否被篡改。

两个相同的字符串永远会计算出相同的hashCode，否则基于hashCode定位的HashMap就无法正常工作。这也是为什么当我们自定义一个class时，覆写equals()方法时我们必须正确覆写hashCode()方法。

1. 哈希碰撞

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

碰撞能不能避免？答案是不能。碰撞是一定会出现的，因为输出的字节长度是固定的，String的hashCode()输出是4字节整数，最多只有4294967296种输出，但输入的数据长度是不固定的，有无数种输入。所以，哈希算法是把一个无限的输入集合映射到一个有限的输出集合，必然会产生碰撞。
碰撞不可怕，我们担心的不是碰撞，而是碰撞的概率，因为碰撞概率的高低关系到哈希算法的安全性。一个安全的哈希算法必须满足：

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

不能猜测输出是指：输入的任意一个bit的变化会造成输出完全不同，这样就很难从输出反推输入（只能依靠暴力穷举）。

2. 常用哈希算法

哈希算法，根据碰撞概率，哈希算法的输出长度越长，就越难产生碰撞，也就越安全。

常用的哈希算法有：

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

Java标准库提供了常用的哈希算法，通过统一的接口进行调用。
以MD5算法为例，看看如何对输入内容计算哈希：

public class Demo01 {
	public static void main(String[] args) throws NoSuchAlgorithmException {
		//获取消息摘要对象
		MessageDigest md = MessageDigest.getInstance("MD5");
		
		//1.使用Md5进行消息加密
//		byte[]str ="还想继续考研".getBytes();
//		byte[]b=md.digest(str);
//		System.out.println("加密前的信息:"+Arrays.toString(str));//加密前的信息:[-24, -65, -104, -26, -125, -77, -25, -69, -89, -25, -69, -83, -24, -128, -125, -25, -96, -108]
//		System.out.println("加密后的信息:"+Arrays.toString(b));//加密后的信息:[-119, -28, -47, 120, 114, -79, 7, -1, 59, -98, -69, 65, -37, -111, -87, -120]
//		System.out.println("加密信息的长度:"+b.length);//加密信息的长度:16
		
//		// 2.大量的数据进行加密
		md.update("还是想考研".getBytes());
		md.update("zkt".getBytes());
		md.update("c罗".getBytes());
		
		//3.加密
		byte[] result = md.digest();
		System.out.println("加密后的信息"+Arrays.toString(result));//加密后的信息[-52, 50, -102, -69, -95, 11, -59, -6, 68, -125, 74, -45, 6, 26, 108, 75]
		System.out.println("加密信息的长度"+result.length);//加密信息的长度16
		System.out.println("转16进制的字符串"+byteToString(result));//转16进制的字符串cc329abba10bc5fa44834ad3061a6c4b
	}
	public static String byteToString(byte[] b) {
		StringBuilder sb = new StringBuilder();
		for (byte c : b) {
			// 1.将10字节数字转成16进制的字符串
			sb.append(String.format("%02x", c));
		}
		return sb.toString();
	}
}

使用MessageDigest时，我们首先根据哈希算法获取一个MessageDigest实例，然后，反复调用update(byte[])输入数据。当输入结束后，调用digest()方法获得byte[]数组表示的摘要，最后，把它转换为十六进制的字符串。

---

使用MD5算法来对图片进行加密

//使用MD5算法来对图片进行加密
public class Demo02 {
	public static void main(String[] args) throws IOException, NoSuchAlgorithmException {
		byte[] image =Files.readAllBytes(Paths.get("C:\Users\张柯堂\Desktop\头像.png"));
		
		//获取消息摘要对象
		MessageDigest md5 = MessageDigest.getInstance("MD5");
		
		//加密
		byte[] bytes = md5.digest(image);
		System.out.println(Demo01.byteToString(bytes));//21f50de91db2ce9a80ccfd2f916d13a0
	}
}

SHA-1算法 

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

public class Demo05 {
	public static void main(String[] args) throws NoSuchAlgorithmException {
		// 1.需要加密的信息
		byte[] passwold = "123456".getBytes();
		// 2.创建信息摘要对象
		MessageDigest sha_1 = MessageDigest.getInstance("SHA-1");
		// 3.update()
		sha_1.update(passwold);
		// 4.加密--16进制的字符串
		byte[] result = sha_1.digest();
		System.out.println("加密后的信息：" + Arrays.toString(result));
		System.out.println("加密后的长度：" + result.length);
		System.out.println(Demo01.byteToString(result));
	}

}

自定义HashTools工具类

HashTools类：

public class HashTools {
	//创建消息摘要对象作为静态变量
	private static MessageDigest mesDig;

	//md5加密算法加密信息
	public static String messageMd5(byte[] bytes) throws NoSuchAlgorithmException {
		mesDig = MessageDigest.getInstance("MD5");
		return handle(bytes);
	}
	//sha-1加密算法加密信息
	public static String messageSha_1(byte[] bytes) throws NoSuchAlgorithmException {
		mesDig = MessageDigest.getInstance("SHA-1");
		return handle(bytes);
	}

	//进行加密操作
	public static String handle(byte[] bytes) {
		mesDig.update(bytes);
		byte[] result = mesDig.digest();
		return byteToString(result);
	}

	//将字节数组转16进制的字符串
	public static String byteToString(byte[] b) {
		StringBuilder sb = new StringBuilder();
		for (byte c : b) {
			// 1.将10字节数字转成16进制的字符串
			//2.追加到StringBuilder类中
			sb.append(String.format("%02x", c));
		}
		return sb.toString();
	}

	//str是个16进制的字符串，每两个字符表示一个字节信息
	//将16进制的字符串转10进制的字节数组
	public static byte[] stringTobyte(String str) {
		byte[] result = new byte[str.length() / 2];
		for (int i = 0, j = 0; i < str.length(); i = i + 2, j++) {
			//int num = Integer.parseInt(str.substring(i, i + 2), 16);
			Byte num = Byte.parseByte(str.substring(i, i + 2), 16);
			result[j] = (byte)num;
		}
		return result;
	}
}

public class Demo06 {
	public static void main(String[] args) throws NoSuchAlgorithmException {
		byte[]  passWorldString = "123456".getBytes();
		//MD5
		String resultMd5=HashTools.messageMd5(passWorldString);
		//SHA-1
		String reulstSha1=HashTools.messageSha_1(passWorldString);

		System.out.println(resultMd5.length());//32
		System.out.println(reulstSha1.length());//40
	}

}

3. 哈希算法的用途

校验下载文件

因为相同的输入永远会得到相同的输出，因此，如果输入被修改了，得到的输出就会不同。我们在网站上下载软件的时候，经常看到下载页显示的MD5哈希值：
如何判断下载到本地的软件是原始的、未经篡改的文件？我们只需要自己计算一下本地文件的哈希值，再与官网公开的哈希值对比，如果相同，说明文件下载正确，否则，说明文件已被篡改。

 存储用户密码

哈希算法的另一个重要用途是存储用户口令。如果直接将用户的原始口令存放到数据库中，会产生极大的安全风险：

• 数据库管理员能够看到用户明文口令；
• 数据库数据一旦泄漏，黑客即可获取用户明文口令。

username	password
bob	123456789
alice	sdfsdfsdf
tim	justdoit

不存储用户的原始口令，那么如何对用户进行认证？方法是存储用户口令的哈希，例如，MD5。在用户输入原始口令后，系统计算用户输入的原始口令的MD5并与数据库存储的MD5对比，如果一致，说明口令正确，否则，口令错误。

因此，数据库存储用户名和口令的表内容应该像下面这样：

username	password
bob	25f9e794323b453885f5181f1b624d0b
alice	73a90acaae2b1ccc0e969709665bc62f
tim	19f9f30bd097d4c066d758fb01b75032

这样一来，数据库管理员看不到用户的原始口令。即使数据库泄漏，黑客也无法拿到用户的原始口令。想要拿到用户的原始口令，必须用暴力穷举的方法，一个口令一个口令地试，直到某个口令计算的MD5恰好等于指定值。


使用哈希口令时，还要注意防止彩虹表攻击。


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

常用口令	MD5
hello123	f30aa7a662c728b7407c54ae6bfd27d1
12345678	25d55ad283aa400af464c76d713c07ad
passw0rd	bed128365216c019988915ed3add75fb
19700101	570da6d5277a646f6552b8832012f5dc
…	…
wbjxxmy	11d7a82f45f6a176fd9d5c100ccab40a

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


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

经过加盐处理的数据库表，内容如下：

username	salt	password
bob	H1r0a	a5022319ff4c56955e22a74abcc2c210
alice	7$p2w	e5de688c99e961ed6e560b972dab8b6a
tim	z5Sk9	1eee304b92dc0d105904e7ab58fd2f64

//通过随机盐值，低于彩虹表攻击
public class Demo03 {
	public static void main(String[] args) throws NoSuchAlgorithmException {
		byte[] passworld = "123456".getBytes();

		// 获取消息摘要对象
		MessageDigest md5 = MessageDigest.getInstance("MD5");

		// 原始密码信息添加进去
		md5.update(passworld);

		// 产生随机的盐值,并添加进去，进行加盐操作
		String uuidString = UUID.randomUUID().toString().substring(0, 6);
		md5.update(uuidString.getBytes());
		System.out.println(uuidString);//73242d

		byte[] result = md5.digest();
		System.out.println("加密后的字节数组：" + Arrays.toString(result));//加密后的字节数组：[57, 38, 44, -69, -126, -103, 126, 24, 76, -101, -53, 105, 68, -84, -21, -104]
		System.out.println("加密后的字符串：" + Demo01.byteToString(result));//加密后的字符串：39262cbb82997e184c9bcb6944aceb98

	}
}

4. 小结

• 哈希算法可用于验证数据完整性，具有防篡改检测的功能；
• 常用的哈希算法有MD5、SHA-1等；
• 用哈希存储口令时要考虑彩虹表攻击

三、Hmac算法

在前面讲到哈希算法时，我们说，存储用户的哈希口令时，要加盐存储，目的就在于抵御彩虹表攻击。我们回顾一下哈希算法：digest = hash(input)
正是因为相同的输入会产生相同的输出，我们加盐的目的就在于，使得输入有所变化：
digest = hash(salt + input)
这个salt可以看作是一个额外的“认证码”，同样的输入，不同的认证码，会产生不同的输出。因此，要验证输出的哈希，必须同时提供“认证码”。

Hmac算法就是一种基于密钥的消息认证码算法，它的全称是Hash-based Message Authentication Code，是一种更安全的消息摘要算法。
Hmac算法总是和某种哈希算法配合起来用的。例如，我们使用MD5算法，对应的就是Hmac MD5算法，它相当于“加盐”的MD5：HmacMD5 ≈ md5(secure_random_key, input)
因此，HmacMD5可以看作带有一个安全的key的MD5。使用HmacMD5而不是用MD5加salt，有如下好处：

• HmacMD5使用的key长度是64字节，更安全；
• Hmac是标准算法，同样适用于SHA-1等其他哈希算法；
• Hmac输出和原有的哈希算法长度一致。

可见，Hmac本质上就是把key混入摘要的算法。验证此哈希时，除了原始的输入数据，还要提供key。为了保证安全，我们不会自己指定key，而是通过Java标准库的KeyGenerator生成一个安全的随机的key。

//Hmac算法-链接md5
public class Demo06 {
	public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {
//		1.通过名称HmacMD5获取KeyGenerator实例；
		KeyGenerator key = KeyGenerator.getInstance("HmacMD5");
//		2.通过KeyGenerator创建一个SecretKey实例；
		SecretKey secretKey = key.generateKey();
		System.out.println("密钥数组："+Arrays.toString(secretKey.getEncoded()));
		System.out.println("密钥长度："+secretKey.getEncoded().length);
		System.out.println("密钥字符串："+HashTools.byteToString(secretKey.getEncoded()));
		
		
//		3.通过名称HmacMD5获取Mac实例；
		Mac macMd5 = Mac.getInstance("HmacMD5");
//		4.用SecretKey初始化Mac实例；
		macMd5.init(secretKey);
//		5.对Mac实例反复调用update(byte[])输入数据；
		byte[] bytes = "hxjxky".getBytes();
		macMd5.update(bytes);
//		6.调用Mac实例的doFinal()获取最终的哈希值。
		byte[] result = macMd5.doFinal();
		System.out.println("密钥数组："+Arrays.toString(result));
		System.out.println("密钥长度："+result.length);
		System.out.println("密钥字符串："+HashTools.byteToString(result));
		
	}
}

运行结果：
密钥数组：[-36, -58, -62, -96, 52, -96, -28, -43, 29, -20, -73, 126, 110, -120, 26, -2, -16, -79, 111, 48, -111, 119, -104, -76, -71, -61, 48, 1, 88, 45, 85, -112, -21, -94, -19, -104, 17, 13, 34, 23, 79, 13, 4, 96, 32, -105, -108, -10, 121, -47, -85, 49, 8, -108, 22, 116, 39, -126, 17, 56, 15, -84, 114, -94]
密钥长度：64
密钥字符串：dcc6c2a034a0e4d51decb77e6e881afef0b16f30917798b4b9c33001582d5590eba2ed98110d22174f0d0460209794f679d1ab3108941674278211380fac72a2
密钥数组：[-111, -50, 96, 58, -120, -34, -57, -74, 113, 124, -113, -70, -91, 39, 126, 58]
密钥长度：16
密钥字符串：91ce603a88dec7b6717c8fbaa5277e3a

和MD5相比，使用HmacMD5的步骤是：

1. 通过名称HmacMD5获取KeyGenerator实例；
2. 通过KeyGenerator创建一个SecretKey实例；
3. 通过名称HmacMD5获取Mac实例；
4. 用SecretKey初始化Mac实例；
5. 对Mac实例反复调用update(byte[])输入数据；
6. 调用Mac实例的doFinal()获取最终的哈希值。

我们可以用Hmac算法取代原有的自定义的加盐算法，因此，存储用户名和口令的数据库结构如下：

username	secret_key (64 bytes)	password
bob	a8c06e05f92e…5e16	7e0387872a57c85ef6dddbaa12f376de
alice	e6a343693985…f4be	c1f929ac2552642b302e739bc0cdbaac
tim	f27a973dfdc0…6003	af57651c3a8a73303515804d4af43790

有了Hmac计算的哈希和SecretKey，我们想要验证怎么办？这时，SecretKey不能从KeyGenerator生成，而是从一个byte[]数组恢复：

//密钥数组：[53, 11, 1, 43, -63, -58, -22, -65, 99, 41, 78, 76, 99, -84, 99, 66, -115, 106, 28, -14, -52, 45, 32, 64, 29, 118, 18, 105, 28, 14, 26, 63, -84, -34, -41, 8, 116, -78, 13, 124, -16, 60, -64, -124, -2, -55, 25, -84, 104, -56, -84, 39, -68, -27, 13, 127, -117, -102, 31, 75, 42, 24, 37, -127]

//密钥长度：64
//密钥字符串：350b012bc1c6eabf63294e4c63ac63428d6a1cf2cc2d20401d7612691c0e1a3facded70874b20d7cf03cc084fec919ac68c8ac27bce50d7f8b9a1f4b2a182581
//密钥数组：[-73, 87, 121, 49, 11, -15, 82, 65, -80, 124, -110, 73, -119, -28, -32, -42]
//密钥长度：16
//密钥字符串：b75779310bf15241b07c924989e4e0d6

public class Demo07 {
	public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {
//		byte[] keybytes = { 53, 11, 1, 43, -63, -58, -22, -65, 99, 41, 78, 76, 99, -84, 99, 66, -115, 106, 28, -14, -52,
//				45, 32, 64, 29, 118, 18, 105, 28, 14, 26, 63, -84, -34, -41, 8, 116, -78, 13, 124, -16, 60, -64, -124,
//				-2, -55, 25, -84, 104, -56, -84, 39, -68, -27, 13, 127, -117, -102, 31, 75, 42, 24, 37, -127 };

		String string = "350b012bc1c6eabf63294e4c63ac63428d6a1cf2cc2d20401d7612691c0e1a3facded70874b20d7cf03cc084fec919ac68c8ac27bce50d7f8b9a1f4b2a182581";
		byte[] keybytes = HashTools.stringTobyte(string);
		// 恢复密钥:参数1:密钥数组 参数2:算法方式
		SecretKey key = new SecretKeySpec(keybytes, "HmacMD5");

		Mac mac = Mac.getInstance("HmacMD5");
		mac.init(key);
		mac.update("hxjxky".getBytes());
		byte[] result = mac.doFinal();
		System.out.println(HashTools.byteToString(result));//b75779310bf15241b07c924989e4e0d6
	}
}

恢复SecretKey的语句就是new SecretKeySpec(keybytes, “HmacMD5”)。

小结：

Hmac算法是一种标准的基于密钥的哈希算法，可以配合MD5、SHA-1等哈希算法，计算的摘要长度和原摘要算法长度相同。

四、对称加密算法

对称加密算法就是传统的用一个秘钥进行加密和解密。例如，我们常用的WinZIP和WinRAR对压缩包的加密和解密，就是使用对称加密算法：

从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文：

secret = encrypt(key, message);

而解密则相反，它接收密码和密文，然后输出明文：

plain = decrypt(key, secret);

在软件开发中，常用的对称加密算法有：

算法	密钥长度	工作模式	填充模式
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/…

        密钥长度直接决定加密强度，而工作模式和填充模式可以看成是对称加密算法的参数和格式选择。Java标准库提供的算法实现并不包括所有的工作模式和所有填充模式。
        最后，值得注意的是，DES算法由于密钥过短，可以在短时间内被暴力破解，所以现在已经不安全了。

1. 使用AES加密

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

ECB模式

ECB模式是最简单的AES加密模式，它需要一个固定长度的密钥，固定的明文会生成固定的密文。
我们先用ECB模式加密并解密：

//AES+ECB
//1. 根据算法名称/工作模式/填充模式获取Cipher实例；
//2. 根据算法名称初始化一个SecretKey实例，密钥必须是指定长度；
//3. 使用SerectKey初始化Cipher实例，并设置加密或解密模式；
//4. 传入明文或密文，获得密文或明文。
public class Demo01 {
	public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException,
			IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
		// 1.message key
		byte[] key = "1234567890abcdef".getBytes();
		String message = "我本将心像明月";
		// 加密操作
		byte[] encodeByte = encodeMessage(key, message.getBytes());
		System.out.println("加密后的信息：" + HashTools.byteToString(encodeByte));

		// 解密操作
		byte[] decodeByte = decodeMessage(key, encodeByte);
		System.out.println("解密后的信息：" + new String(decodeByte));

		System.out.println("加密前的字节数组:" + Arrays.toString(message.getBytes()));
		System.out.println("解密后的信息字节数组:" + Arrays.toString(decodeByte));

	}

	public static byte[] encodeMessage(byte[] key, byte[] message) throws NoSuchAlgorithmException,
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		// 1. 根据算法名称/工作模式/填充模式获取Cipher实例；
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		// 2. 根据算法名称初始化一个SecretKey实例，密钥必须是指定长度；
		SecretKey secretKey = new SecretKeySpec(key, "AES");
		// 3. 使用SerectKey初始化Cipher实例，并设置加密或解密模式；
		cipher.init(Cipher.ENCRYPT_MODE, secretKey);
		// 4. 传入明文或密文，获得密文或明文。
		return cipher.doFinal(message);
	}

	public static byte[] decodeMessage(byte[] key, byte[] encodeMessage) throws NoSuchAlgorithmException,
			NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		// 创建密码对象，需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		// 根据key的字节内容，"恢复"秘钥对象
		SecretKey keySpec = new SecretKeySpec(key, "AES");
		// 初始化秘钥:设置解密模式DECRYPT_MODE
		cipher.init(Cipher.DECRYPT_MODE, keySpec);
		// 根据原始内容(字节),进行解密+

		cipher.update(encodeMessage);
		byte[] result = cipher.doFinal();
		return result;
	}

}

---

public class Demo02 {
	public static void main(String[] args) throws Exception {
		// 原文:
		String message = "我本将心像明月";
		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("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 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 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. 传入明文或密文，获得密文或明文。