密码学
消息摘要
消息摘要（Message Digest）又称为数字摘要(Digital Digest)，它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生，使用数字摘要生成的值是不可以篡改的，为了保证文件或者值的安全。
无论输入的消息有多长，计算出来的消息摘要的长度总是固定的。
例如应用MD5算法摘要的消息有128个比特位，用SHA-1算法摘要的消息最终有160比特位的输出，只要输入的消息不同，对其进行摘要以后产生的摘要消息也必不相同，但相同的输入必会产生相同的输出。
消息摘要是单向、不可逆的。常见算法：MD5、SHA1、SHA256、SHA512。
在线加密消息摘要
public abstract class MessageDigest类为应用程序提供小弟摘要算法功能，如SHA-1、SHA-256。消息摘要是采用任意大小的数据并输出固定长度散列值得安全单向散列函数。
字符串消息摘要
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class MD5Demo {
public static void main(String[] args) throws Exception{
String input = "aa";
String algorithm = "MD5";
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
byte[] bytes = messageDigest.digest(input.getBytes());
System.out.println(new String(bytes));
}
}
|
如果直接输出bytes字节对象会造成以下乱码：
可以像DES一样通过Base64对乱码进行加密处理达到可视化数据的效果。
1
2
3
| byte[] digest = messageDigest.digest(input.getBytes());
System.out.println(Base64.encode(digest));
|
使用在线 md5 加密 ，发现我们生成的值和代码生成的值不一样，那是因为消息摘要不是使用base64进行编码的，所以我们需要把值转成16进制
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
| public class DigestDemo {
public static void main(String[] args) throws Exception {
String input = "aa";
String md5 = getDigest(input, "MD5");
System.out.println(md5);
}
private static String toHex(byte[] digest) throws Exception {
StringBuilder sb = new StringBuilder();
for (byte b : digest) {
String s = Integer.toHexString(b & 0xff);
if (s.length() == 1){
s = "0"+s;
}
sb.append(s);
}
System.out.println("16进制数据的长度：" + sb.toString().getBytes().length);
return sb.toString();
}
private static String getDigest(String input, String algorithm) throws Exception {
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
byte[] digest = messageDigest.digest(input.getBytes());
System.out.println("密文的字节长度:" + digest.length);
return toHex(digest);
}
}
|
其他消息摘要：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class DigestDemo {
public static void main(String[] args) throws Exception {
String input = "aa";
String md5 = getDigest(input, "MD5");
String sha1 = getDigest(input, "SHA-1");
System.out.println(sha1);
String sha256 = getDigest(input, "SHA-256");
System.out.println(sha256);
String sha512 = getDigest(input, "SHA-512");
System.out.println(sha512);
}
}
|
文件消息摘要
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| private static String getDigestFile(String filePath, String algorithm) throws Exception{
FileInputStream fis = new FileInputStream(filePath);
int len;
byte[] buffer = new byte[1024];
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while ( (len = fis.read(buffer))!=-1){
baos.write(buffer,0,len);
}
MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
byte[] digest = messageDigest.digest(baos.toByteArray());
System.out.println("密文的字节长度："+digest.length);
return toHex(digest);
}
|
如使用sha-1算法，可以实现秒传功能，不管咱们如何修改文件的名字，最后得到的值是一样的，如果原文修改了，那么sha-1值就会不一样。
总结：
MD5算法 : 摘要结果16个字节, 转16进制后32个字节SHA1算法 : 摘要结果20个字节, 转16进制后40个字节SHA256算法 : 摘要结果32个字节, 转16进制后64个字节SHA512算法 : 摘要结果64个字节, 转16进制后128个字节
非对称加密
①非对称加密算法又称现代加密算法，常见算法有RSA、ECC
② 非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。
③ 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密钥(privatekey)
④ 公开密钥和私有密钥是一对
⑤ 如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。
⑥ 如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。
⑦ 因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
特点：
- 加密和解密使用不同的密钥
如果使用私钥加密, 只能使用公钥解密
如果使用公钥加密, 只能使用私钥解密
处理数据的速度较慢, 因为安全级别高
public abstract class KeyPairGenerator类用于生成公钥和密钥对。密钥对生成器使用getInstance工厂方法构造。
生成公钥和私钥
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
| import com.sun.org.apache.xml.internal.security.utils.Base64;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
public class RSADemo {
public static void main(String[] args) throws Exception {
String algorithm = "RSA";
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();
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
System.out.println("私钥：" + privateKeyString);
System.out.println("公钥：" + publicKeyString);
String input = "测试";
Cipher cipher = Cipher.getInstance(algorithm);
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("公钥解密：" + new String(bytes1));
}
}
|
必须使用私钥加密公钥解密，或者公钥加密私钥解密，若使用同一把钥匙进行加密解密时，将会出现以下错误：
保存公钥和私钥
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
| public static void main(String[] args) throws Exception {
String algorithm = "RSA";
generateKeyToFile(algorithm, "a.pub", "a.pri");
}
public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
}
|
读取公钥和私钥
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
| import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
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";
PrivateKey privateKey = getPrivateKey("a.pri", algorithm);
PublicKey publicKey = getPublicKey("a.pub", algorithm);
String encode = encryptRSA(algorithm, privateKey, input);
String decode = decryptRSA(algorithm, publicKey, encode);
System.out.println(decode);
}
public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
return keyFactory.generatePublic(spec);
}
public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
return keyFactory.generatePrivate(spec);
}
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.DECRYPT_MODE,key);
byte[] decode = Base64.decode(encrypted);
byte[] bytes = cipher.doFinal(decode);
return new String(bytes);
}
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
Cipher cipher = Cipher.getInstance(algorithm);
cipher.init(Cipher.ENCRYPT_MODE,key);
byte[] bytes = cipher.doFinal(input.getBytes());
return Base64.encode(bytes);
}
}
|
数字签名
数字签名（又称公钥数字签名）是只有信息的发送者才能产生的别人无法伪造的一段数字串，这段数字串同时也是对信息的发送者发送信息真实性的一个有效证明。它是一种类似写在纸上的普通的物理签名，但是使用了公钥加密领域的技术来实现的，用于鉴别数字信息的方法。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。数字签名是非对称密钥加密技术与数字摘要技术的应用。
数字签名的含义：在网络中传输数据时候，给数据添加一个数字签名，表示是谁发的数据，而且还能证明数据没有被篡改。
数字签名的主要作用就是保证了数据的有效性（验证是谁发的）和完整性（证明信息没有被篡改）。
基本原理
为了理解得清楚，我们通过案例一步一步来讲解。话说张三有俩好哥们A、B。由于工作原因，张三和AB写邮件的时候为了安全都需要加密。于是张三想到了数字签名：
整个思路是这个样子的：
第一步：加密采用非对称加密，张三有三把钥匙，两把公钥，送给朋友。一把私钥留给自己。
第二步：A或者B写邮件给张三：A先用公钥对邮件加密，然后张三收到邮件之后使用私钥解密。
第三步：张三写邮件给A或者B：
（1）张三写完邮件，先用hash函数生成邮件的摘要，附着在文章上面，这就完成了数字签名，然后张三再使用私钥加密。就可以把邮件发出去了。
（2）A或者是B收到邮件之后，先把数字签名取下来，然后使用自己的公钥解密即可。这时候取下来的数字签名中的摘要若和张三的一致，那就认为是张三发来的，再对信件本身使用Hash函数，将得到的结果，与上一步得到的摘要进行对比。如果两者一致，就证明这封信未被修改过。
上面的流程我们使用一张图来演示一下：
首先把公钥送给朋友A和B：
数字证书
上面提到我们对签名进行验证时，需要用到公钥。如果公钥是伪造的，那我们无法验证数字签名了，也就根本不可能从数字签名确定对方的合法性了。这时候证书就闪亮登场了。我们可能都有考各种证书的经历，比如说普通话证书，四六级证书等等，但是归根结底，到任何场合我们都能拿出我们的证书来证明自己确实已经考过了普通话，考过了四六级。这里的证书也是同样的道理。
如果不理解证书的作用，我们可以举一个例子，比如说我们的毕业证书，任何公司都会承认。为什么会承认？因为那是国家发得，大家都信任国家。也就是说只要是国家的认证机构，我们都信任它是合法的。
那么这个证书是如何生成的呢？我们再来看一张图：
网页加密
我们看一个应用“数字证书”的实例：https协议。这个协议主要用于网页加密
首先，客户端向服务器发出加密请求。
服务器用自己的私钥加密网页以后，连同本身的数字证书，一起发送给客户端。
客户端（浏览器）的“证书管理器”，有“受信任的根证书颁发机构”列表。客户端会根据这张列表，查看解开数字证书的公钥是否在列表之内。
如果数字证书记载的网址，与你正在浏览的网址不一致，就说明这张证书可能被冒用，浏览器会发出警告。
如果这张数字证书不是由受信任的机构颁发的，浏览器会发出另一种警告。
如果数字证书是可靠的，客户端就可以使用证书中的服务器公钥，对信息进行加密，然后与服务器交换加密信息。
代码实现
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
| import java.security.*;
import com.sun.org.apache.xml.internal.security.utils.Base64;
public class SignatureDemo {
public static void main(String[] args) throws Exception {
String a = "123";
PrivateKey privateKey = RSADemo.getPrivateKey("a.pri", "RSA");
PublicKey publicKey = RSADemo.getPublicKey("a.pub", "RSA");
String signaturedData = getSignature(a, "sha256withrsa", privateKey);
boolean b = verifySignature(a, "sha256withrsa", publicKey, signaturedData);
}
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();
return Base64.encode(sign);
}
private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signaturedData) throws Exception {
Signature signature = Signature.getInstance(algorithm);
signature.initVerify(publicKey);
signature.update(input.getBytes());
return signature.verify(Base64.decode(signaturedData));
}
}
|
keytool工具路径：C:\Program Files\Java\jre1.8.0_91\bin
常用命令：
生成keypair：
1
2
| keytool -genkeypair
keytool -genkeypair -alias lisi（后面部分是为证书指定别名，否则采用默认的名称为mykey）
|
看看keystore中有哪些项目：
1
2
| keytool -list 或 keytool -list -v
keytool -exportcert -alias lisi -file lisi.cer
|
生成可打印的证书：
1
| keytool -exportcert -alias lisi -file lisi.cer –rfc
|
显示数字证书文件中的证书信息：
1
| keytool -printcert -file lisi.cer
|
直接双击lisi.cer，用window系统的内置程序打开lisi.cer
生成私钥公钥
（1）生成密钥证书 下边命令生成密钥证书，采用RSA 算法每个证书包含公钥和私钥
创建一个文件夹，在该文件夹下执行如下命令行：
1
| keytool -genkeypair -alias midkuro -keyalg RSA -keypass midkuro -keystore midkuro.jks -storepass midkuro
|
Keytool是一个java提供的证书管理工具
1
2
3
4
5
| -alias：密钥的别名
-keyalg：使用的hash算法
-keypass：密钥的访问密码
-keystore：密钥库文件名，xc.keystore保存了生成的证书
-storepass：密钥库的访问密码
|
（2）查询证书信息
1
| keytool -list -keystore migkuro.jks
|
（3）删除别名
1
| keytool -delete -alias midkuro -keystore midkuro.jks
|
导出公钥
openssl是一个加解密工具包，这里使用openssl来导出公钥信息。
安装 openssl，安装资料目录下的Win64OpenSSL-1_1_0g.exe
配置openssl的path环境变量，如下图：
本教程配置在C:\OpenSSL-Win64\bin
cmd进入midkuro.jks文件所在目录执行如下命令（如下命令在windows下执行，会把-变成中文方式，请将它改成英文的-）：
1
| keytool -list -rfc --keystore midkuro.jks | openssl x509 -inform pem -pubkey
|
下面段内容是公钥：
1
2
3
4
5
6
7
8
9
| -----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvFsEiaLvij9C1Mz+oyAm
t47whAaRkRu/8kePM+X8760UGU0RMwGti6Z9y3LQ0RvK6I0brXmbGB/RsN38PVnh
cP8ZfxGUH26kX0RK+tlrxcrG+HkPYOH4XPAL8Q1lu1n9x3tLcIPxq8ZZtuIyKYEm
oLKyMsvTviG5flTpDprT25unWgE4md1kthRWXOnfWHATVY7Y/r4obiOL1mS5bEa/
iNKotQNnvIAKtjBM4RlIDWMa6dmz+lHtLtqDD2LF1qwoiSIHI75LQZ/CNYaHCfZS
xtOydpNKq8eb1/PGiLNolD4La2zf0/1dlcr5mkesV570NxRmU1tFm8Zd3MZlZmyv
9QIDAQAB
-----END PUBLIC KEY-----
|
将上边的公钥拷贝到文本public.key文件中，合并为一行,可以将它放到需要实现授权认证的工程中。
