关于密码:人人都懂密码学一篇最易懂的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个字符，而且每行以“rn”符完结     */    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:Userscwx970190Documentsapache-tomcat-9.0.38.zip", "SHA-1");        System.out.println(sha1);        String sha512 = getDigestFile("C:Userscwx970190Documentsapache-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了，密码学博大精深，本文只是浅尝辄止，对于密码学的常识始终都在更新，心愿下次能够给大家带来更前沿、更实用的密码学相干常识，喜爱的老铁欢送关注点赞，笔芯！！！

点击关注，第一工夫理解华为云陈腐技术~

一、 密码学发展史