密码学基本概念

密码在我们的生活中有着重要的作用，那么密码究竟来自何方，为何会产生呢？

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

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

古典密码学

在古代的战争中，多见使用隐藏信息的方式保护重要的通信资料。比如先把需要保护的信息用化学药水写到纸上，药水干后，纸上看不出任何的信息，需要使用另外的化学药水涂抹后才可以阅读纸上的信息。

这些方法都是在保护重要的信息不被他人获取，但藏信息的方式比较容易被他人识破，例如增加哨兵的排查力度，就会发现其中的猫腻，因而随后发展出了较难破解的古典密码学。

① 替换法

替换法很好理解，就是用固定的信息将原文替换成无法直接阅读的密文信息。例如将 b 替换成 w ，e 替换成p ，这样bee 单词就变换成了wpp，不知道替换规则的人就无法阅读出原文的含义。

替换法有单表替换和多表替换两种形式。

单表替换即只有一张原文密文对照表单，发送者和接收者用这张表单来加密解密。在上述例子中，表单即为：a b c d e - s w t r p 。

多表替换即有多张原文密文对照表单，不同字母可以用不同表单的内容替换。

例如约定好表单为：表单 1：abcde-swtrp 、表单2：abcde-chfhk 、表单 3：abcde-jftou。

规定第一个字母用第三张表单，第二个字母用第一张表单，第三个字母用第二张表单，这时 bee单词就变成了

(312)fpk ，破解难度更高，其中 312 又叫做密钥，密钥可以事先约定好，也可以在传输过程中标记出来。

② 移位法

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

例如约定好向后移动2位（abcde - cdefg），这样 bee 单词就变换成了dgg 。

同理替换法，移位法也可以采用多表移位的方式，典型的多表案例是“维尼吉亚密码”（又译维热纳尔密码），属于多表密码的一种形式。

③ 古典密码破解方式

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

英文单词中字母出现的频率是不同的，e以12.702%的百分比占比最高，z 只占到0.074%，感兴趣的可以去百科查字母频率详细统计数据。如果密文数量足够大，仅仅采用频度分析法就可以破解单表的替换法或移位法。

多表的替换法或移位法虽然难度高一些，但如果数据量足够大的话，也是可以破解的。以维尼吉亚密码算法为例，破解方法就是先找出密文中完全相同的字母串，猜测密钥长度，得到密钥长度后再把同组的密文放在一起，使用频率分析法破解。

近代密码学

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

恩尼格玛机

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

恩尼格玛机

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

现代密码学

① 散列函数

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

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

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

② 对称密码

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

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

③ 非对称密码

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

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

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

如何设置密码才安全

• 密码不要太常见，不要使用类似于123456式的常用密码。

• 各应用软件密码建议不同，避免出现一个应用数据库被脱库，全部应用密码崩塌，

• 可在设置密码时增加注册时间、注册地点、应用特性等方法。例如tianjin123456，表示在天津注册的该应用。

ASCII编码

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

示例代码

创建maven项目 encrypt-decrypt

添加pom文件

7
1
 <dependencies>
2
        <dependency>
3
            <groupId>commons-io</groupId>
4
            <artifactId>commons-io</artifactId>
5
            <version>2.6</version>
6
        </dependency>
7
    </dependencies>

创建类 com.atguigu.ascii.AsciiDemo

字符转换成ascii码

18
1
package com.atguigu.ascii;
2

3
/**
4
 * AsciiDemo
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-03-17
8
 * @Description:
9
 */
10
public class AsciiDemo {
11

12
    public static void main(String[] args) {
13
        char a = 'A';
14
        int b = a;
15
        // 打印ascii码
16
        System.out.println(b);
17
    }
18
}

运行程序

字符串转换成ascii码

25
1
package com.atguigu.ascii;
2

3
/**
4
 * AsciiDemo
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-03-17
8
 * @Description:
9
 */
10
public class AsciiDemo {
11

12
    public static void main(String[] args) {
13
//        char a = 'A';
14
//        int b = a;
15
//        System.out.println(b);
16
        String a = "AaZ";
17
        // 获取ascii码，需要把字符串转成字符
18
        char[] chars = a.toCharArray();
19
        for (char c : chars) {
20

21
            int asciiCode = c;
22
            System.out.println(asciiCode);
23
        }
24
    }
25
}

运行程序

恺撒加密

中国古代加密

看一个小故事 ， 看看古人如何加密和解密：

公元683年，唐中宗即位。随后，武则天废唐中宗，立第四子李旦为皇帝，但朝政大事均由她自己专断。

裴炎、徐敬业和骆宾王等人对此非常不满。徐敬业聚兵十万，在江苏扬州起兵。裴炎做内应，欲以拆字手段为其传递秘密信息。后因有人告密，裴炎被捕，未发出的密信落到武则天手中。这封密信上只有“青鹅”二字，群臣对此大惑不解。

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

外国加密

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

凯撒密码最早由古罗马军事统帅盖乌斯·尤利乌斯·凯撒在军队中用来传递加密信息，故称凯撒密码。这是一种位移加密方式，只对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’计数。

凯撒位移加密

创建类 KaiserDemo，把 hello world 往右边移动3位

29
1
package com.atguigu.kaiser;
2

3
/**
4
 * KaiserDemo
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-03-17
8
 * @Description:
9
 */
10
public class KaiserDemo {
11
    public static void main(String[] args) {
12
        String input = "Hello world";
13
        // 往右边移动3位
14
        int key = 3;
15
        // 用来拼接
16
        StringBuilder sb = new StringBuilder();
17
        // 字符串转换成字节数组
18
        char[] chars = input.toCharArray();
19
        for (char c : chars) {
20
            int asciiCode = c;
21
            // 移动3位
22
            asciiCode = asciiCode + key;
23
            char newChar = (char) asciiCode;
24
            sb.append(newChar);
25
        }
26

27
        System.out.println(sb.toString());
28
    }
29
}

运行

凯撒加密和解密

67
1
package com.atguigu.kaiser;
2

3
/**
4
 * KaiserDemo
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-03-16
8
 * @Description:
9
 */
10
public class KaiserDemo {
11
    public static void main(String[] args) {
12
        String orignal = "Hello world";
13
        // 往右边偏移三位
14
        int key = 3;
15
        // 选中我即将抽取的代码，按快捷键Ctrl + Alt + M 
16
        String encryptKaiser =  encryptKaiser(orignal,key);
17
        System.out.println("加密：" + encryptKaiser);
18
        String decryptKaiser =  decryptKaiser(encryptKaiser,key);
19
        System.out.println("解密：" + decryptKaiser);
20
    }
21
    /**
22
     * 使用凯撒加密方式解密数据
23
     *
24
     * @param encryptedData :密文
25
     * @param key           :密钥
26
     * @return : 源数据
27
     */
28
    public static String decryptKaiser(String encryptedData, int key) {
29
        // 将字符串转为字符数组
30
        char[] chars = encryptedData.toCharArray();
31
        StringBuilder sb = new StringBuilder();
32
        for (char aChar : chars) {
33
            // 获取字符的ASCII编码
34
            int asciiCode = aChar;
35
            // 偏移数据
36
            asciiCode -= key;
37
            // 将偏移后的数据转为字符
38
            char result = (char) asciiCode;
39
            // 拼接数据
40
            sb.append(result);
41
        }
42
        return sb.toString();
43
    }
44
    /**
45
     * 使用凯撒加密方式加密数据
46
     *
47
     * @param orignal :原文
48
     * @param key     :密钥
49
     * @return :加密后的数据
50
     */
51
    public static String encryptKaiser(String orignal, int key) {
52
        // 将字符串转为字符数组
53
        char[] chars = orignal.toCharArray();
54
        StringBuilder sb = new StringBuilder();
55
        for (char aChar : chars) {
56
            // 获取字符的ascii编码
57
            int asciiCode = aChar;
58
            // 偏移数据
59
            asciiCode += key;
60
            // 将偏移后的数据转为字符
61
            char result = (char) asciiCode;
62
            // 拼接数据
63
            sb.append(result);
64
        }
65
        return sb.toString();
66
    }
67
}

频度分析法破解恺撒加密

密码棒

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

比如这样：

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

比如这样：

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

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

频率分析解密法

密码棒是不是太简单了些？

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

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

• 将明文字母的出现频率与密文字母的频率相比较的过程

• 通过分析每个符号出现的频率而轻易地破译代换式密码

• 在每种语言中，冗长的文章中的字母表现出一种可对之进行分辨的频率。

• e是英语中最常用的字母，其出现频率为八分之一

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

运行 FrequencyAnalysis.java 用来统计每个字符出现的次数

运行 FrequencyAnalysis.java 里面 main 函数里面的 encryptFile 方法 对程序进行加密

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

在根目录会生成一个 article_en.txt 文件，然后我们统计这个文件当中每个字符出现的次数

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

运行程序

我们来看看 频度分析法如何工作的

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

运行程序

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

Byte和bit

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

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

关系: 1Byte = 8bit

获取字符串byte

20
1
package com.atguigu.bytebit;
2

3
/**
4
 * ByteBit
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-03-17
8
 * @Description:
9
 */
10
public class ByteBit {
11
    public static void main(String[] args) {
12
        String a = "a";
13
        byte[] bytes = a.getBytes();
14
        for (byte b : bytes) {
15
            int c=b;
16
            // 打印发现byte实际上就是ascii码
17
            System.out.println(c);
18
        }
19
    }
20
}

运行程序

byte对应bit

23
1
package com.atguigu.bytebit;
2

3
/**
4
 * ByteBit
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-03-17
8
 * @Description:
9
 */
10
public class ByteBit {
11
    public static void main(String[] args) {
12
        String a = "a";
13
        byte[] bytes = a.getBytes();
14
        for (byte b : bytes) {
15
            int c=b;
16
            // 打印发现byte实际上就是ascii码
17
            System.out.println(c);
18
            // 我们在来看看每个byte对应的bit，byte获取对应的bit
19
            String s = Integer.toBinaryString(c);
20
            System.out.println(s);
21
        }
22
    }
23
}

运行程序

打印出来应该是8个bit，但前面是0，没有打印 ，从打印结果可以看出来，一个英文字符 ，占一个字节

中文对应的字节

25
1
// 中文在GBK编码下, 占据2个字节
2
// 中文在UTF-8编码下, 占据3个字节
3
package com.atguigu;
4

5
/**
6
 * ByteBitDemo
7
 *
8
 * @Author: 尚硅谷
9
 * @CreateTime: 2020-03-16
10
 * @Description:
11
 */
12
public class ByteBitDemo {
13
    public static void main(String[] args) throws Exception{
14

15
        String a = "尚";
16
        byte[] bytes = a.getBytes();
17
        for (byte b : bytes) {
18
            System.out.print(b + "   ");
19
            String s = Integer.toBinaryString(b);
20
            System.out.println(s);
21
        }
22
    }
23
    
24
    
25
}

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

我们修改 编码格式 , 编码格式改成 GBK ，我们在运行发现变成了 2 个字节

xxxxxxxxxx
15
1
public static void main(String[] args) throws Exception{
2

3
        String a = "尚";
4

5
        // 在中文情况下，不同的编码格式，对应不同的字节
6
       //GBK :编码格式占2个字节
7
       // UTF-8：编码格式占3个字节
8
        byte[] bytes = a.getBytes("GBK");
9
       // byte[] bytes = a.getBytes("UTF-8");
10
        for (byte b : bytes) {
11
            System.out.print(b + "   ");
12
            String s = Integer.toBinaryString(b);
13
            System.out.println(s);
14
        }
15
    }

运行程序

英文对应的字节

我们在看看英文，在不同的编码格式占用多少字节

23
1
package com.atguigu.bytebit;
2

3
/**
4
 * ByteBit
5
 *
6
 * @Author: 尚硅谷
7
 * @CreateTime: 2020-04-12
8
 * @Description:
9
 */
10
public class ByteBit {
11
    public static void main(String[] args) throws Exception{
12

13
        String a = "A";
14
        byte[] bytes = a.getBytes();
15
        // 在中文情况下，不同的编码格式，对应不同的字节
16
//        byte[] bytes = a.getBytes("GBK");
17
        for (byte b : bytes) {
18
            System.out.print(b + "   ");
19
            String s = Integer.toBinaryString(b);
20
            System.out.println(s);
21
        }
22
    }
23
}

运行程序

常见加密方式

对称加密

• 采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。

• 示例

  • 我们现在有一个原文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使用

DES加密

示例代码 des加密算法

Cipher ：文档 https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html#getInstance-java.lang.String-

43
1
package com.atguigu.desaes;
2

3
import javax.crypto.Cipher;
4
import javax.crypto.spec.SecretKeySpec;
5

6
/**
7
 * DesAesDemo
8
 *
9
 * @Author: 尚硅谷
10
 * @CreateTime: 2020-03-17
11
 * @Description:
12
 */
13
public class DesAesDemo {
14
    public static void main(String[] args) throws Exception{
15
        // 原文
16
        String input = "硅谷";
17
        // des加密必须是8位
18
        String key = "123456";
19
        // 算法
20
        String algorithm = "DES";
21

22
        String transformation = "DES";
23
        // Cipher：密码，获取加密对象
24
        // transformation:参数表示使用什么类型加密
25
        Cipher cipher = Cipher.getInstance(transformation);
26
        // 指定秘钥规则
27
        // 第一个参数表示：密钥，key的字节数组
28
        // 第二个参数表示：算法
29
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
30
        // 对加密进行初始化
31
        // 第一个参数：表示模式，有加密模式和解密模式
32
        // 第二个参数：表示秘钥规则
33
        cipher.init(Cipher.ENCRYPT_MODE,sks);
34
        // 进行加密
35
        byte[] bytes = cipher.doFinal(input.getBytes());
36
        // 打印字节，因为ascii码有负数，解析不出来，所以乱码
37
//        for (byte b : bytes) {
38
//            System.out.println(b);
39
//        }
40
        // 打印密文
41
        System.out.println(new String(bytes));
42
    }
43
}

运行：

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

使用 base64 进行编码

base64 导包的时候，需要注意 ，别导错了，需要导入 apache 包

运行程序

DES解密

使用 ctrl + alt + m 快捷键抽取代码

78
1
package com.atguigu.desaes;
2

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

5
import javax.crypto.Cipher;
6
import javax.crypto.spec.IvParameterSpec;
7
import javax.crypto.spec.SecretKeySpec;
8

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

12
    public static void main(String[] args) throws Exception {
13
        String input ="硅谷";
14
        // DES加密算法，key的大小必须是8个字节
15
        String key = "12345678";
16

17
        String transformation = "DES"; // 9PQXVUIhaaQ=
18
        // 指定获取密钥的算法
19
        String algorithm = "DES";
20
        String encryptDES = encryptDES(input, key, transformation, algorithm);
21
        System.out.println("加密:" + encryptDES);
22
        String s = decryptDES(encryptDES, key, transformation, algorithm);
23
        System.out.println("解密:" + s);
24

25
    }
26

27
    /**
28
     * 使用DES加密数据
29
     *
30
     * @param input          : 原文
31
     * @param key            : 密钥(DES,密钥的长度必须是8个字节)
32
     * @param transformation : 获取Cipher对象的算法
33
     * @param algorithm      : 获取密钥的算法
34
     * @return : 密文
35
      * @throws Exception
36
      */
37
    private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
38
        // 获取加密对象
39
        Cipher cipher = Cipher.getInstance(transformation);
40
        // 创建加密规则
41
        // 第一个参数key的字节
42
        // 第二个参数表示加密算法
43
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
44
        // ENCRYPT_MODE：加密模式
45
        // DECRYPT_MODE: 解密模式
46
        // 初始化加密模式和算法
47
        cipher.init(Cipher.ENCRYPT_MODE,sks);
48
        // 加密
49
        byte[] bytes = cipher.doFinal(input.getBytes());
50

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

54
         return encode;
55
     }
56

57
    /**
58
     * 使用DES解密
59
     *
60
     * @param input          : 密文
61
     * @param key            : 密钥
62
     * @param transformation : 获取Cipher对象的算法
63
     * @param algorithm      : 获取密钥的算法
64
     * @throws Exception
65
     * @return: 原文
66
     */
67
    private static String decryptDES(String input, String key, String transformation, String algorithm) throws Exception {
68
        // 1,获取Cipher对象
69
        Cipher cipher = Cipher.getInstance(transformation);
70
        // 指定密钥规则
71
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
72
        cipher.init(Cipher.DECRYPT_MODE, sks);
73
        // 3. 解密，上面使用的base64编码，下面直接用密文
74
        byte[] bytes = cipher.doFinal(Base64.decode(input));
75
        //  因为是明文，所以直接返回
76
        return new String(bytes);
77
    }
78
}

运行程序：

Base64 算法简介

6
1
Base64是网络上最常见的用于传输8Bit字节码的可读性编码算法之一
2
可读性编码算法不是为了保护数据的安全性，而是为了可读性
3
可读性编码不改变信息内容，只改变信息内容的表现形式
4
所谓Base64，即是说在编码过程中使用了64种字符：大写A到Z、小写a到z、数字0到9、“+”和“/”
5
Base58是Bitcoin(比特币)中使用的一种编码方式，主要用于产生Bitcoin的钱包地址
6
相比Base64，Base58不使用数字"0"，字母大写"O"，字母大写"I"，和字母小写"i"，以及"+"和"/"符号

Base64 算法原理

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

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

base64 构成原则

① 小写 a - z = 26个字母

② 大写 A - Z = 26个字母

③ 数字 0 - 9 = 10 个数字

④ + / = 2个符号

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

base64补等号测试

15
1
package com.atguigu;
2

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

5

6
public class TestBase64 {
7
    public static void main(String[] args) {
8
        //  1：MQ== 表示一个字节，不够三个字节，所以需要后面通过 == 号补齐
9
        System.out.println(Base64.encode("1".getBytes()));
10
//        System.out.println(Base64.encode("12".getBytes()));
11
//        System.out.println(Base64.encode("123".getBytes()));
12
//        // 硅谷:中文占6个字节，6 * 8 = 48 ，刚刚好被整除，所以没有等号
13
//        System.out.println(Base64.encode("硅谷".getBytes()));
14
    }
15
}

运行：

AES加密解密

AES 加密解密和 DES 加密解密代码一样，只需要修改加密算法就行，拷贝 ESC 代码

77
1
package com.atguigu.desaes;
2
import com.sun.org.apache.xml.internal.security.utils.Base64;
3

4
import javax.crypto.Cipher;
5
import javax.crypto.spec.SecretKeySpec;
6

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

10
    public static void main(String[] args) throws Exception {
11
        String input ="硅谷";
12
        // AES加密算法，比较高级，所以key的大小必须是16个字节
13
        String key = "1234567812345678";
14

15
        String transformation = "AES"; // 9PQXVUIhaaQ=
16
        // 指定获取密钥的算法
17
        String algorithm = "AES";
18
        // 先测试加密，然后在测试解密
19
        String encryptDES = encryptDES(input, key, transformation, algorithm);
20
        System.out.println("加密:" + encryptDES);
21
        String s = dncryptDES(encryptDES, key, transformation, algorithm);
22
        System.out.println("解密:" + s);
23

24
    }
25

26
    /**
27
     * 使用DES加密数据
28
     *
29
     * @param input          : 原文
30
     * @param key            : 密钥(DES,密钥的长度必须是8个字节)
31
     * @param transformation : 获取Cipher对象的算法
32
     * @param algorithm      : 获取密钥的算法
33
     * @return : 密文
34
     * @throws Exception
35
     */
36
    private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
37
        // 获取加密对象
38
        Cipher cipher = Cipher.getInstance(transformation);
39
        // 创建加密规则
40
        // 第一个参数key的字节
41
        // 第二个参数表示加密算法
42
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
43
        // ENCRYPT_MODE：加密模式
44
        // DECRYPT_MODE: 解密模式
45
        // 初始化加密模式和算法
46
        cipher.init(Cipher.ENCRYPT_MODE,sks);
47
        // 加密
48
        byte[] bytes = cipher.doFinal(input.getBytes());
49

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

53
        return encode;
54
    }
55

56
    /**
57
     * 使用DES解密
58
     *
59
     * @param input          : 密文
60
     * @param key            : 密钥
61
     * @param transformation : 获取Cipher对象的算法
62
     * @param algorithm      : 获取密钥的算法
63
     * @throws Exception
64
     * @return: 原文
65
     */
66
    private static String dncryptDES(String input, String key, String transformation, String algorithm) throws Exception {
67
        // 1,获取Cipher对象
68
        Cipher cipher = Cipher.getInstance(transformation);
69
        // 指定密钥规则
70
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
71
        cipher.init(Cipher.DECRYPT_MODE, sks);
72
        // 3. 解密
73
        byte[] bytes = cipher.doFinal(Base64.decode(input));
74

75
        return new String(bytes);
76
    }
77
}

运行程序：AES 加密的密钥key ， 需要传入16个字节

在运行程序

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

举例子

20
1
package com.atguigu;
2

3

4
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
5

6

7
public class TestBase64 {
8
    public static void main(String[] args) {
9
        String str="TU0jV0xBTiNVYys5bEdiUjZlNU45aHJ0bTdDQStBPT0jNjQ2NDY1Njk4IzM5OTkwMDAwMzAwMA==";
10

11

12
        String rlt1=new String(Base64.decode(str));
13

14
        String rlt2=Base64.decode(str).toString();
15

16
        System.out.println(rlt1);
17

18
        System.out.println(rlt2);
19
    }
20
}

结果是：

3
1
MM#WLAN#Uc+9lGbR6e5N9hrtm7CA+A==#646465698#399900003000
2

3
[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（）对象打印的时候使用

加密模式

加密模式：https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html

ECB

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

• 优点 : 可以并行处理数据

• 缺点 : 同样的原文生成同样的密文, 不能很好的保护数据

• 同时加密，原文是一样的，加密出来的密文也是一样的

CBC

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

• 优点 : 同样的原文生成的密文不一样

• 缺点 : 串行处理数据.

填充模式

• 当需要按块处理的数据, 数据长度不符合块处理需求时, 按照一定的方法填充满块长的规则

NoPadding

• 不填充.

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

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

PKCS5Padding

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

Tips

• 默认情况下, 加密模式和填充模式为 : ECB/PKCS5Padding

• 如果使用CBC模式, 在初始化Cipher对象时, 需要增加参数, 初始化向量IV : IvParameterSpec iv = new IvParameterSpec(key.getBytes());

加密模式和填充模式

15
1
AES/CBC/NoPadding (128)
2
AES/CBC/PKCS5Padding (128)
3
AES/ECB/NoPadding (128)
4
AES/ECB/PKCS5Padding (128)
5
DES/CBC/NoPadding (56)
6
DES/CBC/PKCS5Padding (56)
7
DES/ECB/NoPadding (56)
8
DES/ECB/PKCS5Padding (56)
9
DESede/CBC/NoPadding (168)
10
DESede/CBC/PKCS5Padding (168)
11
DESede/ECB/NoPadding (168)
12
DESede/ECB/PKCS5Padding (168)
13
RSA/ECB/PKCS1Padding (1024, 2048)
14
RSA/ECB/OAEPWithSHA-1AndMGF1Padding (1024, 2048)
15
RSA/ECB/OAEPWithSHA-256AndMGF1Padding (1024, 2048)

加密模式和填充模式例子

86
1
package com.atguigu.desaes;
2

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

5
import javax.crypto.Cipher;
6
import javax.crypto.spec.IvParameterSpec;
7
import javax.crypto.spec.SecretKeySpec;
8

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

12
    public static void main(String[] args) throws Exception {
13
        String input ="硅谷";
14
        // DES加密算法，key的大小必须是8个字节
15
        String key = "12345678";
16
        // 指定获取Cipher的算法,如果没有指定加密模式和填充模式,ECB/PKCS5Padding就是默认值
17
        //     String transformation = "DES"; // 9PQXVUIhaaQ=
18
        //String transformation = "DES/ECB/PKCS5Padding"; // 9PQXVUIhaaQ=
19
        // CBC模式,必须指定初始向量,初始向量中密钥的长度必须是8个字节
20
        //String transformation = "DES/CBC/PKCS5Padding"; // 9PQXVUIhaaQ=
21
        // NoPadding模式,原文的长度必须是8个字节的整倍数 ，所以必须把 硅谷改成硅谷12
22
        String transformation = "DES/CBC/NoPadding"; // 9PQXVUIhaaQ=
23
        // 指定获取密钥的算法
24
        String algorithm = "DES";
25
        String encryptDES = encryptDES(input, key, transformation, algorithm);
26
        System.out.println("加密:" + encryptDES);
27
//        String s = dncryptDES(encryptDES, key, transformation, algorithm);
28
//        System.out.println("解密:" + s);
29

30
    }
31

32
    /**
33
     * 使用DES加密数据
34
     *
35
     * @param input          : 原文
36
     * @param key            : 密钥(DES,密钥的长度必须是8个字节)
37
     * @param transformation : 获取Cipher对象的算法
38
     * @param algorithm      : 获取密钥的算法
39
     * @return : 密文
40
     * @throws Exception
41
     */
42
    private static String encryptDES(String input, String key, String transformation, String algorithm) throws Exception {
43
        // 获取加密对象
44
        Cipher cipher = Cipher.getInstance(transformation);
45
        // 创建加密规则
46
        // 第一个参数key的字节
47
        // 第二个参数表示加密算法
48
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
49
        // ENCRYPT_MODE：加密模式
50
        // DECRYPT_MODE: 解密模式
51
         // 初始向量，参数表示跟谁进行异或，初始向量的长度必须是8位
52
//        IvParameterSpec iv = new IvParameterSpec(key.getBytes());
53
         // 初始化加密模式和算法
54
        cipher.init(Cipher.ENCRYPT_MODE,sks);
55
        // 加密
56
        byte[] bytes = cipher.doFinal(input.getBytes());
57

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

61
        return encode;
62
    }
63

64
    /**
65
     * 使用DES解密
66
     *
67
     * @param input          : 密文
68
     * @param key            : 密钥
69
     * @param transformation : 获取Cipher对象的算法
70
     * @param algorithm      : 获取密钥的算法
71
     * @throws Exception
72
     * @return: 原文
73
     */
74
    private static String dncryptDES(String input, String key, String transformation, String algorithm) throws Exception {
75
        // 1,获取Cipher对象
76
        Cipher cipher = Cipher.getInstance(transformation);
77
        // 指定密钥规则
78
        SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
79
//        IvParameterSpec iv = new IvParameterSpec(key.getBytes());
80
        cipher.init(Cipher.DECRYPT_MODE, sks);
81
        // 3. 解密
82
        byte[] bytes = cipher.doFinal(Base64.decode(input));
83

84
        return new String(bytes);
85
    }
86
}

运行程序：

修改成 CBC 加密 模式

xxxxxxxxxx
1
1
 String transformation = "DES/CBC/PKCS5Padding";

运行 ，报错，需要添加一个参数

修改加密代码：

运行程序

修改填充模式

xxxxxxxxxx
1
1
String transformation = "DES/CBC/NoPadding";

运行报错 NoPadding 这种填充模式 原文必须是8个字节的整倍数

修改运行

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

消息摘要

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

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

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

特点

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

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

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

常见算法 :

xxxxxxxxxx
4
1
- MD5
2
- SHA1
3
- SHA256
4
- SHA512

在线获取消息摘要

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

数字摘要

获取字符串消息摘要

xxxxxxxxxx
26
1
package com.atguigu.digest;
2

3
import javax.sound.midi.Soundbank;
4
import java.security.MessageDigest;
5

6
/**
7
 * DigestDemo1
8
 *
9
 * @Author: 尚硅谷
10
 * @CreateTime: 2020-03-17
11
 * @Description:
12
 */
13
public class DigestDemo1 {
14

15
    public static void main(String[] args) throws Exception{
16
        // 原文
17
        String input = "aa";
18
        // 算法
19
        String algorithm = "MD5";
20
        // 获取数字摘要对象
21
        MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
22
        // 获取消息数字摘要的字节数组
23
        byte[] digest = messageDigest.digest(input.getBytes());
24
        System.out.println(new String(digest));
25
    }
26
}

运行

base64 编码

xxxxxxxxxx
30
1
package com.atguigu.digest;
2

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

5
import javax.sound.midi.Soundbank;
6
import java.security.MessageDigest;
7

8
/**
9
 * DigestDemo1
10
 *
11
 * @Author: 尚硅谷
12
 * @CreateTime: 2020-03-17
13
 * @Description:
14
 */
15
public class DigestDemo1 {
16

17
    public static void main(String[] args) throws Exception{
18
        // 原文
19
        String input = "aa";
20
        // 算法
21
        String algorithm = "MD5";
22
        // 获取数字摘要对象
23
        MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
24
        // 消息数字摘要
25
        byte[] digest = messageDigest.digest(input.getBytes());
26
//        System.out.println(new String(digest));
27
        // base64编码
28
        System.out.println(Base64.encode(digest));
29
    }
30
}

运行

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

数字摘要转换成 16 进制

xxxxxxxxxx
2
1
// 4124bc0a9335c27f086f24ba207a4912     md5 在线校验
2
// QSS8CpM1wn8IbyS6IHpJEg==             消息摘要使用的是16进制

代码转成16进制

xxxxxxxxxx
47
1
package com.atguigu.digest;
2

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

5
import javax.sound.midi.Soundbank;
6
import java.security.MessageDigest;
7

8
/**
9
 * DigestDemo1
10
 *
11
 * @Author: 尚硅谷
12
 * @CreateTime: 2020-03-17
13
 * @Description:
14
 */
15
public class DigestDemo1 {
16

17
    public static void main(String[] args) throws Exception{
18
        // 4124bc0a9335c27f086f24ba207a4912     md5 在线校验
19
        // QSS8CpM1wn8IbyS6IHpJEg==             消息摘要使用的是16进制
20
        // 原文
21
        String input = "aa";
22
        // 算法
23
        String algorithm = "MD5";
24
        // 获取数字摘要对象
25
        MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
26
        // 消息数字摘要
27
        byte[] digest = messageDigest.digest(input.getBytes());
28
//        System.out.println(new String(digest));
29
        // base64编码
30
//        System.out.println(Base64.encode(digest));
31
        // 创建对象用来拼接
32
        StringBuilder sb = new StringBuilder();
33

34
        for (byte b : digest) {
35
            // 转成 16进制
36
            String s = Integer.toHexString(b & 0xff);
37
            //System.out.println(s);
38
            if (s.length() == 1){
39
                // 如果生成的字符只有一个，前面补0
40
                s = "0"+s;
41
            }
42
            sb.append(s);
43
        }
44
        System.out.println(sb.toString());
45
        
46
    }
47
}

运行

其他数字摘要算法

xxxxxxxxxx
70
1
package com.atguigu.digest;
2

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

5
import javax.sound.midi.Soundbank;
6
import java.security.MessageDigest;
7
import java.security.NoSuchAlgorithmException;
8

9
/**
10
 * DigestDemo1
11
 *
12
 * @Author: 尚硅谷
13
 * @CreateTime: 2020-03-17
14
 * @Description:
15
 */
16
public class DigestDemo1 {
17

18
    public static void main(String[] args) throws Exception{
19
        // 4124bc0a9335c27f086f24ba207a4912     md5 在线校验
20
        // QSS8CpM1wn8IbyS6IHpJEg==             消息摘要使用的是16进制
21
        // 原文
22
        String input = "aa";
23
        // 算法
24
        String algorithm = "MD5";
25
        // 获取数字摘要对象
26
        String md5 = getDigest(input, "MD5");
27
        System.out.println(md5);
28

29
        String sha1 = getDigest(input, "SHA-1");
30
        System.out.println(sha1);
31

32
        String sha256 = getDigest(input, "SHA-256");
33
        System.out.println(sha256);
34

35
        String sha512 = getDigest(input, "SHA-512");
36
        System.out.println(sha512);
37

38

39
    }
40

41
    private static String toHex(byte[] digest) throws Exception {
42

43
//        System.out.println(new String(digest));
44
        // base64编码
45
//        System.out.println(Base64.encode(digest));
46
        // 创建对象用来拼接
47
        StringBuilder sb = new StringBuilder();
48

49
        for (byte b : digest) {
50
            // 转成 16进制
51
            String s = Integer.toHexString(b & 0xff);
52
            if (s.length() == 1){
53
                // 如果生成的字符只有一个，前面补0
54
                s = "0"+s;
55
            }
56
            sb.append(s);
57
        }
58
        System.out.println("16进制数据的长度：" + sb.toString().getBytes().length);
59
        return sb.toString();
60
    }
61

62
    private static String getDigest(String input, String algorithm) throws Exception {
63
        MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
64
        // 消息数字摘要
65
        byte[] digest = messageDigest.digest(input.getBytes());
66
        System.out.println("密文的字节长度:" + digest.length);
67

68
        return toHex(digest);
69
    }
70
}

运行

获取文件消息摘要

xxxxxxxxxx
79
1
package com.atguigu.digest;
2

3
import com.sun.org.apache.xml.internal.security.utils.Base64;
4
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
5
import sun.misc.BASE64Decoder;
6

7
import java.io.ByteArrayOutputStream;
8
import java.io.FileInputStream;
9
import java.security.MessageDigest;
10

11
/**
12
 * DigestDemo
13
 *
14
 * @Author: 尚硅谷
15
 * @CreateTime: 2020-03-16
16
 * @Description:
17
 */
18
public class DigestDemo {
19

20
    public static void main(String[] args) throws Exception{
21
        String input = "aa";
22
        String algorithm = "MD5";
23

24
        // sha1 可以实现秒传功能
25

26
        String sha1 = getDigestFile("apache-tomcat-9.0.10-windows-x64.zip", "SHA-1");
27
        System.out.println(sha1);
28

29
        String sha512 = getDigestFile("apache-tomcat-9.0.10-windows-x64.zip", "SHA-512");
30
        System.out.println(sha512);
31

32
        String md5 = getDigest("aa", "MD5");
33
        System.out.println(md5);
34

35
        String md51 = getDigest("aa ", "MD5");
36
        System.out.println(md51);
37
    }
38

39
    private static String getDigestFile(String filePath, String algorithm) throws Exception{
40
        FileInputStream fis = new FileInputStream(filePath);
41
        int len;
42
        byte[] buffer = new byte[1024];
43
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
44
        while ( (len =  fis.read(buffer))!=-1){
45
            baos.write(buffer,0,len);
46
        }
47
        // 获取消息摘要对象
48
        MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
49
        // 获取消息摘要
50
        byte[] digest = messageDigest.digest(baos.toByteArray());
51
        System.out.println("密文的字节长度："+digest.length);
52
        return toHex(digest);
53
    }
54

55
    private static String getDigest(String input, String algorithm) throws Exception{
56
        MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
57
        byte[] digest = messageDigest.digest(input.getBytes());
58
        System.out.println("密文的字节长度："+digest.length);
59
        return toHex(digest);
60
    }
61

62
    private static String toHex(byte[] digest) {
63
        //        System.out.println(new String(digest));
64
        // 消息摘要进行表示的时候，是用16进制进行表示
65
        StringBuilder sb = new StringBuilder();
66
        for (byte b : digest) {
67
            // 转成16进制
68

69
            String s = Integer.toHexString(b & 0xff);
70
            // 保持数据的完整性，前面不够的用0补齐
71
            if (s.length()==1){
72
                s="0"+s;
73
            }
74
            sb.append(s);
75
        }
76
        System.out.println("16进制数据的长度:"+ sb.toString().getBytes().length);
77
        return sb.toString();
78
    }
79
}