人人都该懂密码学通用密码学原理与应用实战，学会自主设计安全技术方案

标签：实战 加密 String algorithm Base64 密钥 人人 import 密码学

人人都该懂密码学通用密码学原理与应用实战，学会自主设计安全技术方案

 

密码与我们的生活息息相关，远到国家机密，近到个人账户，我们每天都在跟密码打交道：

那么，密码从何而来？生活中常见的加密是怎么实现的？怎么保证个人信息安全？本文将从这几方面进行浅谈，如有纰漏，敬请各位大佬指正。

代码部分从第二章节——常见加密算法开始，对代码比较感兴趣的铁子们可以从第二章节开始看。

一、 密码学发展史

密码学是网络安全、信息安全、区块链等产品的基础，常见的非对称加密、对称加密、散列函数等，都属于密码学范畴。

密码学有数千年的历史，从最开始的替换法到如今的非对称加密算法，经历了古典密码学，近代密码学和现代密码学三个阶段。密码学不仅仅是数学家们的智慧，更是如今网络空间安全的重要基础。

1.1 古典密码学

古典密码的加密方式主要有替换法和移位法。古典密码虽然很简单，但是在密码史上是使用的最久的加密方式，直到“概率论”的数学方法被发现，古典密码就被破解了。

1.2 近代密码学

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

恩尼格玛机

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

1.3 现代密码学

① 散列函数

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

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

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

② 对称密码

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

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

③ 非对称密码

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

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

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

二、常见加密算法

让我们来看看生活中常见的几种加密方式：

2.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使用

2.1.1 DES加密

示例代码 des加密算法

Cipher ：文档 docs.oracle.com/javase/8/do…

运行：

出现这个bug的原因是DES算法规定，key必须是8个字节；

修改 密钥 key = “12345678” ，再次运行 ，出现乱码是因为对应的字节出现负数，但负数没有出现在 ascii 码表里面，所以出现乱码，需要配合base64进行转码

2.1.2 拓展：base64编码

在Java 8中，Base64编码已经成为Java类库的标准。

Java 8 内置了 Base64 编码的编码器和解码器。

Base64工具类提供了一套静态方法获取下面三种BASE64编解码器：

**- 基本：**输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。

**- URL：**输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。

**- MIME：**输出隐射到MIME友好格式。输出每行不超过76字符，并且使用’\r’并跟随’\n’作为分割。编码输出最后没有行分割。

上面的例子用Java8自带的base64进行编码：

运行：

除了上面的编码方式外，base64还有其他的编码方式，由于笔者时间有限，没有过多研究，在此放入一个demo，供大家参考：

运行：

2.1.3 DES解密

在2.1.1中的例子基础上加入解密方法

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class DesDemo {// DES加密算法,key的大小必须是8个字节

public static void main(String[] args) throws Exception {String input ="华为";// DES加密算法，key的大小必须是8个字节String key = "12345678";String transformation = "DES"; // 9PQXVUIhaaQ=// 指定获取密钥的算法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);

}

/**
 * 使用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);// ENCRYPT_MODE：加密模式// DECRYPT_MODE: 解密模式// 初始化加密模式和算法cipher.init(Cipher.ENCRYPT_MODE,sks);// 加密byte[] bytes = cipher.doFinal(input.getBytes());// 输出加密后的数据String encode = new String(Base64.getEncoder().encode(bytes), "UTF-8");

//System.out.println(encode);return encode;}

/**
 * 使用DES解密
 *
 * @param input: 密文
 * @param key: 密钥
 * @param transformation : 获取Cipher对象的算法
 * @param algorithm: 获取密钥的算法
 * @throws Exception
 * @return: 原文
 */
private static String decryptDES(String input, String key, String transformation, String algorithm) throws Exception {// 1,获取Cipher对象Cipher cipher = Cipher.getInstance(transformation);// 指定密钥规则SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);cipher.init(Cipher.DECRYPT_MODE, sks);// 3\. 解密，上面使用的base64编码，下面直接用密文byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(input));

//System.out.println("解密" + new String(decode, "UTF-8"));//因为是明文，所以直接返回return new String(bytes);}
}

 

• 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

运行：

2.1.4 AES加密解密

AES 加密解密和 DES 加密解密代码一样，只需要修改加密算法就行，在此不做过多阐述，值得注意的是：AES 加密的密钥key ， 需要传入16个字节.

2.1.5 加密模式

AES的加密模式如下：

参考链接：docs.oracle.com/javase/8/do…

这里主要介绍两种加密模式：ECB和CBC

ECB

Electronic codebook, 电子密码本. 需要加密的消息按照块密码的块大小被分为数个块，并对每个块进行独立加密

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

CBC

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

• 优点 : 同样的原文生成的密文不一样
• 缺点 : 串行处理数据.

2.1.6 填充模式

当需要按块处理的数据, 数据长度不符合块处理需求时, 按照一定的方法填充满块长的规则，这里主要介绍以下两种：

NoPadding

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

PKCS5Padding

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

Tips

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

加密模式和填充模式：其中括号里数字表示加密位数，位数越高，则越安全

加密模式和填充模式例子

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020\. All rights reserved.
 */

package com.huawei.it.jalor.boot.test;

/**
 * 功能描述: 加密模式和填充模式例子
 *
 * @author cWX970190
 * @since 2020-10-11
 */
import com.sun.org.apache.xml.internal.security.utils.Base64;

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

public class DesDemo {// DES加密算法,key的大小必须是8个字节public static void main(String[] args) throws Exception {String input ="华为";// DES加密算法，key的大小必须是8个字节String key = "12345678";// 指定获取Cipher的算法,如果没有指定加密模式和填充模式,ECB/PKCS5Padding就是默认值// String transformation = "DES"; // 9PQXVUIhaaQ=//String transformation = "DES/ECB/PKCS5Padding"; // 9PQXVUIhaaQ=// CBC模式,必须指定初始向量,初始向量中密钥的长度必须是8个字节
//String transformation = "DES/CBC/PKCS5Padding"; // 9PQXVUIhaaQ=// NoPadding模式,原文的长度必须是8个字节的整倍数 ，所以必须把 硅谷改成硅谷12String transformation = "DES/CBC/NoPadding"; // 9PQXVUIhaaQ=// 指定获取密钥的算法String algorithm = "DES";String encryptDES = encryptDES(input, key, transformation, algorithm);System.out.println("加密:" + encryptDES);String s = dncryptDES(encryptDES, key, transformation, algorithm);System.out.println("解密:" + s);}/** * 使用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);// ENCRYPT_MODE：加密模式// DECRYPT_MODE: 解密模式// 初始向量，参数表示跟谁进行异或，初始向量的长度必须是8位
//IvParameterSpec iv = new IvParameterSpec(key.getBytes());// 初始化加密模式和算法cipher.init(Cipher.ENCRYPT_MODE,sks);// 加密byte[] bytes = cipher.doFinal(input.getBytes());// 输出加密后的数据String encode = Base64.encode(bytes);return encode;}/** * 使用DES解密 * * @param input: 密文 * @param key: 密钥 * @param transformation : 获取Cipher对象的算法 * @param algorithm: 获取密钥的算法 * @throws Exception * @return: 原文 */private static String dncryptDES(String input, String key, String transformation, String algorithm) throws Exception {// 1,获取Cipher对象Cipher cipher = Cipher.getInstance(transformation);// 指定密钥规则SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
//IvParameterSpec iv = new IvParameterSpec(key.getBytes());cipher.init(Cipher.DECRYPT_MODE, sks);// 3\. 解密byte[] bytes = cipher.doFinal(Base64.decode(input));return new String(bytes);}
}

 

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

运行：

非填充模式下，原文必须是8个字节，修改加密模式为：

 String transformation = "DES/CBC/PKCS5Padding";

 

• 1

再次运行：

发现加密没有问题，但是解密时需要添加一个参数，添加参数并修改初始化规则：

 // 初始向量，参数表示跟谁进行异或，初始向量的长度必须是8位IvParameterSpec iv = new IvParameterSpec(key.getBytes());// 初始化加密模式和算法cipher.init(Cipher.ENCRYPT_MODE,sks,iv);

 

• 1

再次运行：

在测试 AES 的时候需要注意，key需要16个字节，加密向量也需要16个字节 ，其他方式跟 DES 一样。

2.2 消息摘要（单向散列）函数

消息摘要（Message Digest）又称为数字摘要(Digital Digest)

它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生

使用数字摘要生成的值是不可以篡改的，为了保证文件或者值的安全

2.2.1 特点

无论输入的消息有多长，计算出来的消息摘要的长度总是固定的。例如应用MD5算法摘要的消息有128个比特位，用SHA-1算法摘要的消息最终有160比特位的输出

只要输入的消息不同，对其进行摘要以后产生的摘要消息也必不相同；但相同的输入必会产生相同的输出

消息摘要是单向、不可逆的

常见算法 :

• MD5
• SHA1
• SHA256
• SHA512

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

2.2.2 获取字符串消息摘要

运行：

使用在线 md5 加密 ，发现我们生成的值和代码生成的值不一样，那是因为消息摘要不是使用base64进行编码的，所以我们需要把值转成16进制。

数字摘要转换成 16 进制

package com.huawei.it.jalor.boot.test;

/**
 * 功能描述
 *
 * @author cWX970190
 * @since 2020-10-11
 */

import com.sun.org.apache.xml.internal.security.utils.Base64;

import java.security.MessageDigest;

public class DigestDemo1 {public static void main(String[] args) throws Exception{// 原文String input = "aa";// 算法String algorithm = "MD5";// 获取数字摘要对象MessageDigest messageDigest = MessageDigest.getInstance(algorithm);// 获取消息数字摘要的字节数组byte[] digest = messageDigest.digest(input.getBytes("UTF-8"));//System.out.println(new String(digest));// base64编码
//System.out.println(Base64.encode(digest));// 创建对象用来拼接StringBuilder sb = new StringBuilder();for (byte b : digest) {// 转成 16进制String s = Integer.toHexString(b & 0xff);//System.out.println(s);if (s.length() == 1){// 如果生成的字符只有一个，前面补0s = "0"+s;}sb.append(s);}System.out.println(sb.toString());}
}

 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

运行，结果和在线一致：

2.2.3 其他消息摘要算法

/**
 * 功能描述
 *
 * @author cWX970190
 * @since 2020-10-11
 */
import java.security.MessageDigest;

/**
 * DigestDemo1
 *
 * @Author: 陈志强
 * @CreateTime: 2020-03-17
 * @Description:
 */
public class DigestDemo1 {public static void main(String[] args) throws Exception{// 4124bc0a9335c27f086f24ba207a4912 md5 在线校验// QSS8CpM1wn8IbyS6IHpJEg== 消息摘要使用的是16进制// 原文String input = "aa";// 算法String algorithm = "MD5";// 获取数字摘要对象String md5 = getDigest(input, "MD5");System.out.println(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);}private static String toHex(byte[] digest) throws Exception {

//System.out.println(new String(digest));// base64编码
//System.out.println(Base64.encode(digest));// 创建对象用来拼接StringBuilder sb = new StringBuilder();for (byte b : digest) {// 转成 16进制String s = Integer.toHexString(b & 0xff);if (s.length() == 1){// 如果生成的字符只有一个，前面补0s = "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
• 17
• 18
• 19
• 20

运行：

2.2.4 获取文件消息摘要

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.security.MessageDigest;

/**
 * DigestDemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-11
 * @Description:
 */
public class DigestDemo {public static void main(String[] args) throws Exception{String input = "aa";String algorithm = "MD5";// sha1 可以实现秒传功能String sha1 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-1");System.out.println(sha1);String sha512 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-512");System.out.println(sha512);

//String md5 = getDigest("aa", "MD5");
//System.out.println(md5);
//
//String md51 = getDigest("aa ", "MD5");
//System.out.println(md51);}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);}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);}private static String toHex(byte[] digest) {//System.out.println(new String(digest));// 消息摘要进行表示的时候，是用16进制进行表示StringBuilder sb = new StringBuilder();for (byte b : digest) {// 转成16进制String s = Integer.toHexString(b & 0xff);// 保持数据的完整性，前面不够的用0补齐if (s.length()==1){s="0"+s;}sb.append(s);}System.out.println("16进制数据的长度:"+ sb.toString().getBytes().length);return sb.toString();}
}

 

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

运行结果：

查看官网上的sha512加密结果，发现一致：

使用 sha-1 算法，可以实现秒传功能，只要是同一文件的加密，不管如何修改文件的名字，最后得到的值是一样的，具体可以自己测试。

不过，如果原文不一样，例如，下图上面的原文多两个空格：

运行后：

总结

• MD5算法 : 摘要结果16个字节, 转16进制后32个字节
• SHA1算法 : 摘要结果20个字节, 转16进制后40个字节
• SHA256算法 : 摘要结果32个字节, 转16进制后64个字节
• SHA512算法 : 摘要结果64个字节, 转16进制后128个字节

2.3 非对称加密

简介：

① 非对称加密算法又称现代加密算法。

② 非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。

③ 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥(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

2.3.1 生成公钥和私钥

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;
/**
 * RSAdemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
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();// 对公私钥进行base64编码String privateKeyString = Base64.encode(privateKeyEncoded);String publicKeyString = Base64.encode(publicKeyEncoded);// 打印私钥System.out.println(privateKeyString);// 打印公钥System.out.println(publicKeyString);}
}

 

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

运行程序，先打印私钥，再打印公钥：

2.3.2 私钥加密

import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
 * RSAdemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
public class RSAdemo {public static void main(String[] args) throws Exception {String input = "华为";// 加密算法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();// 对公私钥进行base64编码String privateKeyString = Base64.encode(privateKeyEncoded);String publicKeyString = Base64.encode(publicKeyEncoded);// 创建加密对象// 参数表示加密算法Cipher cipher = Cipher.getInstance(algorithm);// 初始化加密// 第一个参数:加密的模式// 第二个参数：使用私钥进行加密cipher.init(Cipher.ENCRYPT_MODE,privateKey);// 私钥加密byte[] bytes = cipher.doFinal(input.getBytes());System.out.println(Base64.encode(bytes));}
}

 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

运行程序：

2.3.3 私钥加密私钥解密

public class RSAdemo {public static void main(String[] args) throws Exception {String input = "华为";// 加密算法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();// 对公私钥进行base64编码String privateKeyString = Base64.encode(privateKeyEncoded);String publicKeyString = Base64.encode(publicKeyEncoded);// 创建加密对象// 参数表示加密算法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,privateKey);// 对密文进行解密，不需要使用base64，因为原文不会乱码byte[] bytes1 = cipher.doFinal(bytes);System.out.println(new String(bytes1));}
}

 

• 1
• 2

运行结果error，因为私钥加密，只能公钥解密：

2.3.4 私钥加密公钥解密

修改2.3.3中的代码

// 公钥进行解密
cipher.init(Cipher.DECRYPT_MODE,publicKey);

 

• 1
• 2

再次运行

2.3.5 公钥加密和公钥解密

一样会报错

2.3.6 保存公私钥

有些情况下需要把加密和解密的方法全部到本地的根目录下面：

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020\. All rights reserved.
 */

package com.huawei.it.jalor.boot.test;

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.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
 * RSAdemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
public class RSAdemo {public static void main(String[] args) throws Exception {String input = "硅谷";// 加密算法String algorithm = "RSA";//生成密钥对并保存在本地文件中generateKeyToFile(algorithm, "a.pub", "a.pri");//加密
//String s = encryptRSA(algorithm, privateKey, input);// 解密
//String s1 = decryptRSA(algorithm, publicKey, s);
//System.out.println(s1);}/** * 生成密钥对并保存在本地文件中 * * @param algorithm : 算法 * @param pubPath : 公钥保存路径 * @param priPath : 私钥保存路径 * @throws Exception */private 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数组byte[] publicKeyEncoded = publicKey.getEncoded();byte[] privateKeyEncoded = privateKey.getEncoded();// 进行Base64编码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"));}/** * 解密数据 * * @param algorithm: 算法 * @param encrypted: 密文 * @param key: 密钥 * @return : 原文 * @throws Exception */public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{// 创建加密对象// 参数表示加密算法Cipher cipher = Cipher.getInstance(algorithm);// 私钥进行解密cipher.init(Cipher.DECRYPT_MODE,key);// 由于密文进行了Base64编码, 在这里需要进行解码byte[] decode = Base64.decode(encrypted);// 对密文进行解密，不需要使用base64，因为原文不会乱码byte[] bytes1 = cipher.doFinal(decode);System.out.println(new String(bytes1));return new String(bytes1);}/** * 使用密钥加密数据 * * @param algorithm: 算法 * @param input: 原文 * @param key: 密钥 * @return : 密文 * @throws Exception */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());// 对密文进行Base64编码System.out.println(Base64.encode(bytes));return Base64.encode(bytes);}
}

 

• 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

运行程序后，本地多了两个文件，打开：

2.3.7 读取私钥

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;
/**
 * RSAdemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
public class RSAdemo {public static void main(String[] args) throws Exception {String input = "硅谷";// 加密算法String algorithm = "RSA";PrivateKey privateKey = getPrivateKey("a.pri", algorithm);}public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{// 将文件内容转为字符串String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());// 获取密钥工厂KeyFactory keyFactory = KeyFactory.getInstance(algorithm);// 构建密钥规范 进行Base64解码PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));// 生成私钥return keyFactory.generatePrivate(spec);}/** * 生成密钥对并保存在本地文件中 * * @param algorithm : 算法 * @param pubPath : 公钥保存路径 * @param priPath : 私钥保存路径 * @throws Exception */private 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数组byte[] publicKeyEncoded = publicKey.getEncoded();byte[] privateKeyEncoded = privateKey.getEncoded();// 进行Base64编码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"));}/** * 解密数据 * * @param algorithm: 算法 * @param encrypted: 密文 * @param key: 密钥 * @return : 原文 * @throws Exception */public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{ // 创建加密对象// 参数表示加密算法Cipher cipher = Cipher.getInstance(algorithm);// 私钥进行解密cipher.init(Cipher.DECRYPT_MODE,key);// 由于密文进行了Base64编码, 在这里需要进行解码byte[] decode = Base64.decode(encrypted);// 对密文进行解密，不需要使用base64，因为原文不会乱码byte[] bytes1 = cipher.doFinal(decode);System.out.println(new String(bytes1));return new String(bytes1);}/** * 使用密钥加密数据 * * @param algorithm: 算法 * @param input: 原文 * @param key: 密钥 * @return : 密文 * @throws Exception */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());// 对密文进行Base64编码System.out.println(Base64.encode(bytes));return Base64.encode(bytes);}
}

 

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

2.3.8 读取公钥

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;

/**
 * RSAdemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
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 s = encryptRSA(algorithm, privateKey, input);String s1 = decryptRSA(algorithm, publicKey, s);System.out.println(s);System.out.println(s1);}public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{// 将文件内容转为字符串String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());// 获取密钥工厂KeyFactory keyFactory = KeyFactory.getInstance(algorithm);// 构建密钥规范 进行Base64解码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);// 构建密钥规范 进行Base64解码PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));// 生成私钥return keyFactory.generatePrivate(spec);}/** * 生成密钥对并保存在本地文件中 * * @param algorithm : 算法 * @param pubPath : 公钥保存路径 * @param priPath : 私钥保存路径 * @throws Exception */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数组byte[] publicKeyEncoded = publicKey.getEncoded();byte[] privateKeyEncoded = privateKey.getEncoded();// 进行Base64编码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"));}/** * 解密数据 * * @param algorithm: 算法 * @param encrypted: 密文 * @param key: 密钥 * @return : 原文 * @throws Exception */public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{ // 创建加密对象// 参数表示加密算法Cipher cipher = Cipher.getInstance(algorithm);// 私钥进行解密cipher.init(Cipher.DECRYPT_MODE,key);// 由于密文进行了Base64编码, 在这里需要进行解码byte[] decode = Base64.decode(encrypted);// 对密文进行解密，不需要使用base64，因为原文不会乱码byte[] bytes1 = cipher.doFinal(decode);return new String(bytes1);}/** * 使用密钥加密数据 * * @param algorithm: 算法 * @param input: 原文 * @param key: 密钥 * @return : 密文 * @throws Exception */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());// 对密文进行Base64编码return Base64.encode(bytes);}
}

 

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

运行程序

2.4 数字签名

我们经常会用到数字签名，只是大家平时不太注意，比如我们访问银行 ，证券公司，基金公司，金融类的公司网站全部都是 https 协议，如果是 https 协议，那么都需要有一个证书。签名可以用来验证网络传输数据的时候，数据是否被人篡改。

签名的作用简单来说就是证明某个文件上的内容确实是我写的，别人不能冒充我的签名（不可伪造），我也不能否认上面的签名是我的（不可抵赖）。

我们知道，手写签名之所以不能伪造，是因为每一个人的笔迹都是独一无二的，即使模仿，也可以通过专家鉴定分别出来。而不可抵赖，是因为每个人的笔迹都有固定特征，这些特征是很难摆脱的。

正是这两点特性使得手写签名在日常生活中被广泛承认，比如签合同、借条等等。

数字签名的要求是，只有我自己能签我的名字，其他人能验证我的签名，但是不能伪造我的签名。

2.4.1 网页加密

我们看一个应用“数字证书”的实例：https协议。这个协议主要用于网页加密

首先，客户端向服务器发出加密请求。

服务器用自己的私钥加密网页以后，连同本身的数字证书，一起发送给客户端。

客户端（浏览器）的“证书管理器”，有“受信任的根证书颁发机构”列表。客户端会根据这张列表，查看解开数字证书的公钥是否在列表之内。

如果数字证书记载的网址，与你正在浏览的网址不一致，就说明这张证书可能被冒用，浏览器会发出警告。

如果这张数字证书不是由受信任的机构颁发的，浏览器会发出另一种警告。

如果数字证书是可靠的，客户端就可以使用证书中的服务器公钥，对信息进行加密，然后与服务器交换加密信息。

2.4.2 证书从哪里来

“证书中心”（certificate authority，简称CA），为公钥做认证。证书中心用自己的私钥，对公钥和一些相关信息一起加密，生成“数字证书”（Digital Certificate）。

拿到数字证书以后，就可以放心了。以后只要在签名的同时，再附上数字证书就行了。

用CA的公钥解开数字证书，就可以拿到真实的公钥了，然后就能证明“数字签名”是否真的是公司签的。

修改之前的RSAdemo代码:

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020\. All rights reserved.
 */

package com.huawei.it.jalor.boot.test;

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.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * RSAdemo
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
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 s = encryptRSA(algorithm, privateKey, input);String s1 = decryptRSA(algorithm, publicKey, s);System.out.println(s);System.out.println(s1);}public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{// 将文件内容转为字符串String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());// 获取密钥工厂KeyFactory keyFactory = KeyFactory.getInstance(algorithm);// 构建密钥规范 进行Base64解码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);// 构建密钥规范 进行Base64解码PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));// 生成私钥return keyFactory.generatePrivate(spec);}/** * 生成密钥对并保存在本地文件中 * * @param algorithm : 算法 * @param pubPath : 公钥保存路径 * @param priPath : 私钥保存路径 * @throws Exception */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数组byte[] publicKeyEncoded = publicKey.getEncoded();byte[] privateKeyEncoded = privateKey.getEncoded();// 进行Base64编码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"));}/** * 解密数据 * * @param algorithm: 算法 * @param encrypted: 密文 * @param key: 密钥 * @return : 原文 * @throws Exception */public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{// 创建加密对象// 参数表示加密算法Cipher cipher = Cipher.getInstance(algorithm);// 私钥进行解密cipher.init(Cipher.DECRYPT_MODE,key);// 由于密文进行了Base64编码, 在这里需要进行解码byte[] decode = Base64.decode(encrypted);// 对密文进行解密，不需要使用base64，因为原文不会乱码byte[] bytes1 = cipher.doFinal(decode);return new String(bytes1);}/** * 使用密钥加密数据 * * @param algorithm: 算法 * @param input: 原文 * @param key: 密钥 * @return : 密文 * @throws Exception */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());// 对密文进行Base64编码return Base64.encode(bytes);}/** * 从文件中加载公钥 * * @param algorithm : 算法 * @param filePath: 文件路径 * @return : 公钥 * @throws Exception */public static PublicKey loadPublicKeyFromFile(String algorithm, String filePath) throws Exception {// 将文件内容转为字符串String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));return loadPublicKeyFromString(algorithm, keyString);}/** * 从字符串中加载公钥 * * @param algorithm : 算法 * @param keyString : 公钥字符串 * @return : 公钥 * @throws Exception */public static PublicKey loadPublicKeyFromString(String algorithm, String keyString) throws Exception {// 进行Base64解码byte[] decode = Base64.decode(keyString);// 获取密钥工厂KeyFactory keyFactory = KeyFactory.getInstance(algorithm);// 构建密钥规范X509EncodedKeySpec keyspec = new X509EncodedKeySpec(decode);// 获取公钥return keyFactory.generatePublic(keyspec);}/** * 从文件中加载私钥 * * @param algorithm : 算法 * @param filePath: 文件路径 * @return : 私钥 * @throws Exception */public static PrivateKey loadPrivateKeyFromFile(String algorithm, String filePath) throws Exception {// 将文件内容转为字符串String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));return loadPrivateKeyFromString(algorithm, keyString);}/** * 从字符串中加载私钥 * * @param algorithm : 算法 * @param keyString : 私钥字符串 * @return : 私钥 * @throws Exception */public static PrivateKey loadPrivateKeyFromString(String algorithm, String keyString) throws Exception {// 进行Base64解码byte[] decode = Base64.decode(keyString);// 获取密钥工厂KeyFactory keyFactory = KeyFactory.getInstance(algorithm);// 构建密钥规范PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(decode);// 生成私钥return keyFactory.generatePrivate(keyspec);}
}

 

• 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

写一个验证数字签名的类：

/*
 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020\. All rights reserved.
 */

package com.huawei.it.jalor.boot.test;

import com.sun.org.apache.xml.internal.security.utils.Base64;

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

/**
 * 功能描述: 验证数字签名
 *
 * @author cWX970190
 * @since 2020-10-11
 */
public class SignatureDemo {public static void main(String[] args) throws Exception {String a = "123";PublicKey publicKey =RSAdemo.loadPublicKeyFromFile("RSA", "a.pub");PrivateKey privateKey = RSAdemo.loadPrivateKeyFromFile("RSA", "a.pri");String signaturedData = getSignature(a, "sha256withrsa", privateKey);boolean b = verifySignature(a, "sha256withrsa", publicKey, signaturedData);System.out.println(b);}/** * 生成签名 * * @param input: 原文 * @param algorithm: 算法 * @param privateKey : 私钥 * @return : 签名 * @throws Exception */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);}/** * 校验签名 * * @param input: 原文 * @param algorithm: 算法 * @param publicKey: 公钥 * @param signaturedData : 签名 * @return : 数据是否被篡改 * @throws Exception */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));}
}

 

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

运行，验证成功：

拓展： 2.5 Byte和bit

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

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

关系: 1Byte = 8bit

2.5.1 获取字符串byte

/**
 * ByteBit
 *
 * @Author: 陈志强
 * @CreateTime: 2020-10-12
 * @Description:
 */
public class ByteBit {public static void main(String[] args) {String a = "a";byte[] bytes = a.getBytes();for (byte b : bytes) {int c=b;// 打印发现byte实际上就是ascii码System.out.println(c);}}
}

 

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

运行结果：

和ascii码表一致

2.5.2 byte对应bit

public class ByteBit {public static void main(String[] args) {String a = "a";byte[] bytes = a.getBytes();for (byte b : bytes) {int c=b;// 打印发现byte实际上就是ascii码System.out.println(c);// 我们在来看看每个byte对应的bit，byte获取对应的bitString s = Integer.toBinaryString(c);System.out.println(s);}}
}

 

• 1
• 2

运行结果

2.5.3 中文对应的字节

运行程序，我们发现一个中文是有 3 个字节组成：

我们修改 编码格式 , 编码格式改成 GBK

修改代码

 // UTF-8：编码格式占3个字节byte[] bytes = a.getBytes("GBK");

 

• 1

再运行发现变成了 2 个字节

2.5.4 英文对应的字节

运行程序

三、如何设置密码才安全

通过上述密码学发展史的介绍，以及对常见加密算法的阐述，相信大家对密码应该有了较为理性的认识，那么，如何设置密码才安全呢？这里给出一点小建议：

• 密码不要太常见，不要使用类似于123456式的常用密码。
• 各应用软件密码建议不同，避免出现一个应用数据库被脱库，全部应用密码崩塌，
• 可在设置密码时增加注册时间、注册地点、应用特性等方法。

   

标签：实战,加密,String,algorithm,Base64,密钥,人人,import,密码学
From： https://www.cnblogs.com/add1188/p/17780611.html