【人人都懂密码学】一篇最易懂的Java密码学入门教程

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

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

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

一、密码学发展史

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

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

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 ：文档 https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html#getInstance-java.lang.String-

运行：

出现这个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，供大家参考：

import org.junit.Test;

import java.io.UnsupportedEncodingException;

import java.util.Base64;

import java.util.UUID;

/**

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

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

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

 * <p>

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

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

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

 */

public class Base64Test {

    private static final String UTF_8 = "utf-8";

    private static final int MAX = 10;

    @Test

    public void base64() throws UnsupportedEncodingException {

//        test();

//        basic();

        url();

//        mime();

    }

    /**

     * 测试几个特殊字符

     */

    private void test() throws UnsupportedEncodingException {

        String ss = "星期五?/\\|";

        System.out.println("ordinal         : " + ss);

        byte[] encode = Base64.getEncoder().encode(ss.getBytes(UTF_8));

        System.out.println("basic encode    : " + new String(encode, UTF_8));

        byte[] decode = Base64.getDecoder().decode(encode);

        System.out.println("Using Basic     : " + new String(decode, UTF_8));

        byte[] decode1 = Base64.getUrlDecoder().decode(encode);

        System.out.println("Using URL       : " + new String(decode1, UTF_8));

        byte[] decode2 = Base64.getMimeDecoder().decode(encode);

        System.out.println("Using MIME      : " + new String(decode2, UTF_8));

        System.out.println();

    }

    /**

     * MIME编码器会使用基本的字母数字产生BASE64输出，

     * 而且对MIME格式友好：每一行输出不超过76个字符，而且每行以“\r\n”符结束

     */

    private void mime() throws UnsupportedEncodingException {

        StringBuilder sb = new StringBuilder();

        for (int t = 0; t < MAX; ++t) {

            sb.append(UUID.randomUUID().toString());

        }

        byte[] toEncode = sb.toString().getBytes("utf-8");

        String mimeEncoded = Base64.getMimeEncoder().encodeToString(toEncode);

        System.out.println("Using MIME      : ");

        System.out.println(mimeEncoded);

    }

    /**

     * 但由于URL对反斜线“/”有特殊的意义，因此URL编码需要替换掉它，使用下划线替换

     * 如果是使用基本的编码器，那么输出可能会包含反斜线“/”字符，

     * 但是如果使用URL编码器，那么输出的内容对URL来说是安全的。

     */

    private void url() throws UnsupportedEncodingException {

        String ordinal = "subjects?abcd";

        System.out.println("ordinal         : " + ordinal);

        // 输出为: Using Basic Alphabet: c3ViamVjdHM/YWJjZA==

        String basicEncoded = Base64.getEncoder().encodeToString(ordinal.getBytes(UTF_8));

        System.out.println("Using Basic     : " + basicEncoded);

        byte[] decode = Base64.getDecoder().decode(basicEncoded);

        System.out.println("basic decode    : " + new String(decode, UTF_8));

        System.out.println();

        System.out.println("ordinal         : " + ordinal);

        String urlEncoded = Base64.getUrlEncoder().encodeToString(ordinal.getBytes(UTF_8));

        System.out.println("Using URL       : " + urlEncoded);

        byte[] decode1 = Base64.getUrlDecoder().decode(urlEncoded);

        System.out.println("url decode      : " + new String(decode1, UTF_8));

        System.out.println();

        String mimeEncoded = Base64.getMimeEncoder().encodeToString(ordinal.getBytes(UTF_8));

        System.out.println("Using mime       : " + mimeEncoded);

        byte[] decode2 = Base64.getMimeDecoder().decode(mimeEncoded);

        System.out.println("mime decode      : " + new String(decode2, UTF_8));

        System.out.println();

    }

    /**

     * Basic编码是标准的BASE64编码，用于处理常规的需求：输出的内容不添加换行符，而且输出的内容由字母加数字组成。

     */

    private void basic() throws UnsupportedEncodingException {

        String s = "some string";

        System.out.println("ordinal         : " + s);

        // 编码

        String asB64 = Base64.getEncoder().encodeToString(s.getBytes(UTF_8));

        // 输出为: c29tZSBzdHJpbmc=

        System.out.println("Using Basic     : " + asB64);

        // 解码

        byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");

        // 输出为: some string

        System.out.println("basic decode    : " + new String(asBytes, UTF_8));

        System.out.println();

    }

}

运行：

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);

    }

}

运行：

2.1.4 AES加密解密

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

2.1.5 加密模式

AES的加密模式如下：

参考链接：https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html

这里主要介绍两种加密模式：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个字节的整倍数 ，所以必须把 硅谷改成硅谷12

        String 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);

    }

}

运行：

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

 String transformation = "DES/CBC/PKCS5Padding";

再次运行：

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

  // 初始向量，参数表示跟谁进行异或，初始向量的长度必须是8位

        IvParameterSpec iv = new IvParameterSpec(key.getBytes());

        // 初始化加密模式和算法

        cipher.init(Cipher.ENCRYPT_MODE,sks,iv);

再次运行：

在测试 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){

                // 如果生成的字符只有一个，前面补0

                s = "0"+s;

            }

            sb.append(s);

        }

        System.out.println(sb.toString());

    }

}

运行，结果和在线一致：

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){

                // 如果生成的字符只有一个，前面补0

                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);

    }

}

运行：

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();

    }

}

运行结果：

查看官网上的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);

    }

}

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

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));

    }

}

运行程序：

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));

    }

}

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

2.3.4 私钥加密公钥解密

修改2.3.3中的代码

// 公钥进行解密

cipher.init(Cipher.DECRYPT_MODE,publicKey);

再次运行

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);

    }

}

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

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);

    }

}

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);

    }

}

运行程序

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);

    }

}

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

/*

 * 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));

    }

}

运行，验证成功：

拓展： 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);

        }

    }

}

运行结果：

和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获取对应的bit

            String s = Integer.toBinaryString(c);

            System.out.println(s);

        }

    }

}

运行结果

2.5.3 中文对应的字节

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

/**

 * 功能描述

 *

 * @author cWX970190

 * @since 2020-10-11

 */

public class ByteBitDemo {

    public static void main(String[] args) throws Exception{

        String a = "华";

        byte[] bytes = a.getBytes();

        for (byte b : bytes) {

            System.out.print(b + "   ");

            String s = Integer.toBinaryString(b);

            System.out.println(s);

        }

    }

}

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

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

修改代码

 // UTF-8：编码格式占3个字节

        byte[] bytes = a.getBytes("GBK");

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

2.5.4 英文对应的字节

/**

 * ByteBit

 *

 * @Author: 陈志强

 * @CreateTime: 2020-10-12

 * @Description:

 */

public class ByteBit {

    public static void main(String[] args) throws Exception{

        String a = "a";

        byte[] bytes = a.getBytes();

        // 在中文情况下，不同的编码格式，对应不同的字节

//        byte[] bytes = a.getBytes("GBK");

        for (byte b : bytes) {

            System.out.print(b + "   ");

            String s = Integer.toBinaryString(b);

            System.out.println(s);

        }

    }

}

运行程序

三、如何设置密码才安全

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

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

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

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

参考文献：

现代密码学之对称加密-DES及AES算法- element ui
http://element-ui.cn/article/show-97007.aspx

Java Base64 编码与解码----三种实现方式的代码实例
https://blog.csdn.net/qq_27093465/article/details/93977519

网络安全之密码学：信息安全
https://www.bilibili.com/video/av583369085/

好了，本期的分享到此就跟大家saygoodbye了，密码学博大精深，本文只是浅尝辄止，关于密码学的知识一直都在更新，希望下次可以给大家带来更前沿、更实用的密码学相关知识，喜欢的老铁欢迎关注点赞，笔芯！！！

点击关注，第一时间了解华为云新鲜技术~

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

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

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

一、密码学发展史

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

1.1 古典密码学

1.2 近代密码学

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

恩尼格玛机

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

1.3 现代密码学

① 散列函数

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

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

② 对称密码

③ 非对称密码

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

二、常见加密算法

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

2.1 对称加密算法

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

示例

我们现在有一个原文3要发送给B
设置密钥为108, 3 * 108 = 324, 将324作为密文发送给B
B拿到密文324后, 使用324/108 = 3 得到原文

常见加密算法

特点

加密速度快, 可以加密大文件
密文可逆, 一旦密钥文件泄漏, 就会导致数据暴露
加密后编码表找不到对应字符, 出现乱码
一般结合Base64使用

2.1.1 DES加密

示例代码 des加密算法

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

运行：

出现这个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，供大家参考：

import org.junit.Test;

import java.io.UnsupportedEncodingException;

import java.util.Base64;

import java.util.UUID;

/**

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

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

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

 * <p>

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

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

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

 */

public class Base64Test {

    private static final String UTF_8 = "utf-8";

    private static final int MAX = 10;

    @Test

    public void base64() throws UnsupportedEncodingException {

//        test();

//        basic();

        url();

//        mime();

    }

    /**

     * 测试几个特殊字符

     */

    private void test() throws UnsupportedEncodingException {

        String ss = "星期五?/\\|";

        System.out.println("ordinal         : " + ss);

        byte[] encode = Base64.getEncoder().encode(ss.getBytes(UTF_8));

        System.out.println("basic encode    : " + new String(encode, UTF_8));

        byte[] decode = Base64.getDecoder().decode(encode);

        System.out.println("Using Basic     : " + new String(decode, UTF_8));

        byte[] decode1 = Base64.getUrlDecoder().decode(encode);

        System.out.println("Using URL       : " + new String(decode1, UTF_8));

        byte[] decode2 = Base64.getMimeDecoder().decode(encode);

        System.out.println("Using MIME      : " + new String(decode2, UTF_8));

        System.out.println();

    }

    /**

     * MIME编码器会使用基本的字母数字产生BASE64输出，

     * 而且对MIME格式友好：每一行输出不超过76个字符，而且每行以“\r\n”符结束

     */

    private void mime() throws UnsupportedEncodingException {

        StringBuilder sb = new StringBuilder();

        for (int t = 0; t < MAX; ++t) {

            sb.append(UUID.randomUUID().toString());

        }

        byte[] toEncode = sb.toString().getBytes("utf-8");

        String mimeEncoded = Base64.getMimeEncoder().encodeToString(toEncode);

        System.out.println("Using MIME      : ");

        System.out.println(mimeEncoded);

    }

    /**

     * 但由于URL对反斜线“/”有特殊的意义，因此URL编码需要替换掉它，使用下划线替换

     * 如果是使用基本的编码器，那么输出可能会包含反斜线“/”字符，

     * 但是如果使用URL编码器，那么输出的内容对URL来说是安全的。

     */

    private void url() throws UnsupportedEncodingException {

        String ordinal = "subjects?abcd";

        System.out.println("ordinal         : " + ordinal);

        // 输出为: Using Basic Alphabet: c3ViamVjdHM/YWJjZA==

        String basicEncoded = Base64.getEncoder().encodeToString(ordinal.getBytes(UTF_8));

        System.out.println("Using Basic     : " + basicEncoded);

        byte[] decode = Base64.getDecoder().decode(basicEncoded);

        System.out.println("basic decode    : " + new String(decode, UTF_8));

        System.out.println();

        System.out.println("ordinal         : " + ordinal);

        String urlEncoded = Base64.getUrlEncoder().encodeToString(ordinal.getBytes(UTF_8));

        System.out.println("Using URL       : " + urlEncoded);

        byte[] decode1 = Base64.getUrlDecoder().decode(urlEncoded);

        System.out.println("url decode      : " + new String(decode1, UTF_8));

        System.out.println();

        String mimeEncoded = Base64.getMimeEncoder().encodeToString(ordinal.getBytes(UTF_8));

        System.out.println("Using mime       : " + mimeEncoded);

        byte[] decode2 = Base64.getMimeDecoder().decode(mimeEncoded);

        System.out.println("mime decode      : " + new String(decode2, UTF_8));

        System.out.println();

    }

    /**

     * Basic编码是标准的BASE64编码，用于处理常规的需求：输出的内容不添加换行符，而且输出的内容由字母加数字组成。

     */

    private void basic() throws UnsupportedEncodingException {

        String s = "some string";

        System.out.println("ordinal         : " + s);

        // 编码

        String asB64 = Base64.getEncoder().encodeToString(s.getBytes(UTF_8));

        // 输出为: c29tZSBzdHJpbmc=

        System.out.println("Using Basic     : " + asB64);

        // 解码

        byte[] asBytes = Base64.getDecoder().decode("c29tZSBzdHJpbmc=");

        // 输出为: some string

        System.out.println("basic decode    : " + new String(asBytes, UTF_8));

        System.out.println();

    }

}

运行：

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);

    }

}

运行：

2.1.4 AES加密解密

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

2.1.5 加密模式

AES的加密模式如下：

参考链接：https://docs.oracle.com/javase/8/docs/api/javax/crypto/Cipher.html

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

ECB

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

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

CBC

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

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

2.1.6 填充模式

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

NoPadding

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

PKCS5Padding

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

Tips

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

加密模式和填充模式例子

/*

 * 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个字节的整倍数 ，所以必须把 硅谷改成硅谷12

        String 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);

    }

}

运行：

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

 String transformation = "DES/CBC/PKCS5Padding";

再次运行：

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

  // 初始向量，参数表示跟谁进行异或，初始向量的长度必须是8位

        IvParameterSpec iv = new IvParameterSpec(key.getBytes());

        // 初始化加密模式和算法

        cipher.init(Cipher.ENCRYPT_MODE,sks,iv);

再次运行：

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

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

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

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

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

2.2.1 特点

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

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

常见算法 :

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){

                // 如果生成的字符只有一个，前面补0

                s = "0"+s;

            }

            sb.append(s);

        }

        System.out.println(sb.toString());

    }

}

运行，结果和在线一致：

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){

                // 如果生成的字符只有一个，前面补0

                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);

    }

}

运行：

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();

    }

}

运行结果：

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

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

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

运行后：

总结

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);

    }

}

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

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));

    }

}

运行程序：

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));

    }

}

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

2.3.4 私钥加密公钥解密

修改2.3.3中的代码

// 公钥进行解密

cipher.init(Cipher.DECRYPT_MODE,publicKey);

再次运行

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);

    }

}

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

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);

    }

}

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);

    }

}

运行程序

2.4 数字签名

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

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

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

2.4.1 网页加密

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

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

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

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

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

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

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

2.4.2 证书从哪里来

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

用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);

    }

}

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

/*

 * 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));

    }

}

运行，验证成功：

拓展： 2.5 Byte和bit

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

关系: 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);

        }

    }

}

运行结果：

和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获取对应的bit

            String s = Integer.toBinaryString(c);

            System.out.println(s);

        }

    }

}

运行结果

2.5.3 中文对应的字节

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

/**

 * 功能描述

 *

 * @author cWX970190

 * @since 2020-10-11

 */

public class ByteBitDemo {

    public static void main(String[] args) throws Exception{

        String a = "华";

        byte[] bytes = a.getBytes();

        for (byte b : bytes) {

            System.out.print(b + "   ");

            String s = Integer.toBinaryString(b);

            System.out.println(s);

        }

    }

}

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

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

修改代码

 // UTF-8：编码格式占3个字节

        byte[] bytes = a.getBytes("GBK");

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

2.5.4 英文对应的字节

/**

 * ByteBit

 *

 * @Author: 陈志强

 * @CreateTime: 2020-10-12

 * @Description:

 */

public class ByteBit {

    public static void main(String[] args) throws Exception{

        String a = "a";

        byte[] bytes = a.getBytes();

        // 在中文情况下，不同的编码格式，对应不同的字节

//        byte[] bytes = a.getBytes("GBK");

        for (byte b : bytes) {

            System.out.print(b + "   ");

            String s = Integer.toBinaryString(b);

            System.out.println(s);

        }

    }

}

运行程序

三、如何设置密码才安全

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

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

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

参考文献：

现代密码学之对称加密-DES及AES算法- element ui
http://element-ui.cn/article/show-97007.aspx

Java Base64 编码与解码----三种实现方式的代码实例
https://blog.csdn.net/qq_27093465/article/details/93977519

网络安全之密码学：信息安全
https://www.bilibili.com/video/av583369085/

点击关注，第一时间了解华为云新鲜技术~

【人人都懂密码学】一篇最易懂的Java密码学入门教程

一、 密码学发展史

1.1 古典密码学

1.2 近代密码学

1.3 现代密码学

二、常见加密算法

2.1 对称加密算法

2.1.1 DES加密

2.1.2 拓展：base64编码

2.1.3 DES解密

2.1.4 AES加密解密

2.1.5 加密模式

2.1.6 填充模式

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

2.3 非对称加密

2.4 数字签名

拓展： 2.5 Byte和bit

三、如何设置密码才安全

一、 密码学发展史

1.1 古典密码学

1.2 近代密码学

1.3 现代密码学

二、常见加密算法

2.1 对称加密算法

2.1.1 DES加密

2.1.2 拓展：base64编码

2.1.3 DES解密

2.1.4 AES加密解密

2.1.5 加密模式

2.1.6 填充模式

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

2.3 非对称加密

2.4 数字签名

拓展： 2.5 Byte和bit

三、如何设置密码才安全

【人人都懂密码学】一篇最易懂的Java密码学入门教程的相关教程结束。

相关推荐

java输出流怎么表示

java强制类型转换的规则是什么

java隐式转换规则是什么

java调用js脚本的方法是什么

java怎么调用json接口

java如何获取当前日期

java怎么显示当前时间

shell怎么设置java环境变量

一、密码学发展史

一、密码学发展史