对称加密算法原理简介
对称加密算法使用相同的密钥进行加密和解密，它的计算量小，速度快，是最常用的加密方式，也是密码学和各种安全技术应用的基础。本文主要介绍对称加密算法的基本概念、设计思想和原理。
为什么学习密码学
我原来对加密算法的了解仅限于基本的使用，对密码学更没什么认识，也没有什么兴趣，觉得无非就是加密、解密，或者是公钥加密、私钥解密、私钥签名、公钥校验，还有哈希和其它一些派生算法等等。不过学习区块链之后，我才发现密码学的内容很丰富，也很有意思，有很多花样可以玩。
区块链
区块链是重度依赖密码学的技术，虽然主要使用公钥算法，但衍生出的技术和应用很多，例如比特币的基于哈希碰撞的工作量证明，基于脚本的转账方式，以太坊的智能合约，门罗币的环签名，Zcash的零知识证明和IPFS里的各种存储证明等。未来区块链的应用落地也依赖于密码学技术的创新和突破。
信息安全
信息安全不只是重要，而且是越来越重要。从社会发展趋势来说，我们的生活逐步数字化、电子化、网络化、自动化、智能化，越来越多的个人数据在网上传输和存储，人们对数据和隐私的泄露也越来越担心，信息安全也会更加受到重视。
技术的发展也反映了这种趋势。早期的TCP/IP协议是明文传输的，但后来逐渐增加了各种安全机制，例如https已经在逐步取代http，还有像google的QUIC传输协议就直接内嵌了TLS。新的应用也更倾向于采用加密通信方式，例如比特币的协议是明文的，而新的ipfs、libra都直接使用加密协议传输。
数学
最近两年我开始系统学习数学，这也让我对算法的底层原理有了兴趣，不再只是把加密算法当成一个黑盒，而是想了解它们内部的实现机制和设计思想。而且数学理论比较抽象，难以理解，密码学作为数学的一种应用，正好可以当成理论学习的切入点。这样，理论和应用相结合，学习效果上可以相互强化。
古典密码
在现代密码学理论出现之前，加密主要依靠一些编码方面的技巧，没有系统化的理论基础和方法体系，所以加密操作比较简单。一般既需要保护密钥，也需要保护密码算法。具体来说是通过对明文进行各种变换处理，达到混淆和加密的效果。虽然古典密码有一定的限制，但它的基本操作仍然是现代密码的核心组成部分。
古典密码可以简单分为置换和替代两类，具体包括以下几种
移位密码(Shift Cipher)
又称凯撒算法，是历史上最早使用的密码之一，据说是凯撒发明并用来传递军令的。移位密码非常简单，就是对明文做相同的偏移并取模，即E(x)=x+b(mod m)。所以移位密码的密钥空间很小，一般用暴力破解方式就可以找到密钥。
由于移位密码过于简单，现实中很少使用。行李箱上的密码锁用的可以算作是移位密码，虽然它的密钥是3位数，但只要找到转轮上的缺口，调整转轮让3个缺口对准相同的方向，密码就是当前读数的某个偏移，每次把3个数字都同时调整1位，最多只要尝试10次就能找到密码。
移位密码示例：
选择密钥k,0<k<26
k=23
E(x)=x+23(mod 26)
Plain:    ABCDEFGHIJKLMNOPQRSTUVWXYZ
Cipher:   XYZABCDEFGHIJKLMNOPQRSTUVW

Plaintext:  THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
Ciphertext: QEB NRFZH YOLTK CLU GRJMP LSBO QEB IXWV ALD

仿射密码(Affine Cipher)
可以认为是移位密码的改进版，加密函数变成E(x)=ax+b(mod m)，多了一个参数，密钥空间虽略有提升，但还是容易被破解。
置换密码(Permutation Cipher)
通过对明文进行置换操作(重新排序)来达到加密的目的。不过由于密文和明文位于相同的空间，所以不太适合单独使用，但可以作为加密算法的中间步骤用来强化加密效果。
简单置换密码的示例：
明文为：Hello everyone!
密文为：Hoene reley!lvo

列置换密码示例：
6 3 2 4 1 5 
W E A R E D 
I S C O V E 
R E D F L E 
E A T O N C 
E Q K J E U 
从上面的表中，按照列的序号逐列输出，就得到列置换的编码：
EVLNE ACDTK ESEAQ ROFOJ DEECU WIREE

替代密码(Substitution Cipher)
预先建立好一张替换表，然后通过查表，将明文逐一替换为相应的密文，从而实现加密的目的，而这张替换表就是密钥。
按照使用的替换表的数量，替代密码可以分为单表替代密码和多表替代密码。单张替换表会使得明文和明文有相同的分布规律，因此容易被破解。使用多张替换表可以隐藏这种规律，使得破解密码更加困难。Vigenere密码和Hill密码等都是多表替代密码。
替代密码的灵活度比较高，广义的说，前面的几种密码都可以归为(单表)替代密码。虽然替代密码中明文和密文的对应关系导致它容易被破解，但由于其非线性的特点，一般被用来实现现代加密算法中最核心的S-Box。非线性是指密文不是明文和密钥的简单线性组合，而是自由度更高的进行变换。这种特性对于抵抗密码分析非常重要。
替换表：
明文字母表: ABCDEFGHIJKLMNOPQRSTUVWXYZ
密文字母表: ZEBRASCDFGHIJKLMNOPQTUVWXY

明文消息: flee at once. we are discovered!
密文消息: SIAA ZQ LKBA. VA ZOA RFPBLUAOAR!

流密码(Stream Cipher)
在前面的密码中，每个明文字符都是用的相同的密钥来进行加密。实际应用时我们会使用相同的密钥对一组固定大小的连续明文进行加密，这就是分组密码。
流密码是根据密钥产生一个密钥流，然后跟明文进行一对一的异或运算，达到加密的效果。由于明文只是跟密钥流进行简单的异或运算，所以加密强度完全取决于密钥流的随机性。
曾经被用的比较多的RC4就是一种流密码，在Wi-Fi Protected Access(WPA)中使用，后来被发现有漏洞，WPA被使用AES的WPA2代替。现在使用较多的流密码是ChaCha20，是Libra里用到的noise protocol framework的默认加密方式，也是WireGuard VPN使用的加密算法。
密码分析
密码分析专门研究破解信息系统漏洞、获取秘密信息的方法，简单的说，就是研究如何破解加密算法和密钥。下面先简单介绍一下相关的基本术语。
攻击模型
按照攻击者所拥有信息的差别，密码分析可以分为以下几种类别：
唯密文攻击(Ciphertext Only Attack)
攻击者只能获取到一些密文，通过分析密文的规律，进而推测加密算法和密钥的规律。这是最常见的情况，也是攻击难度最高的情况。
已知明文攻击(Known Plaintext Attack)
攻击者能截获到部分明文和使用相同密钥加密得到的密文。这种情况下，攻击者可以根据明文和密文之间的联系，来分析算法和密钥的可能性。
选择明文攻击(Chosen Plaintext Attack)
攻击者能够选择或构造特定的明文，并获取相应的密文，也就是说攻击者能访问加密机。这种情况下，攻击者可以更方便的操纵和分析加密过程，也就更容易破解算法或密钥。
即使攻击者不能直接访问加密机，如果攻击者能够收集足够多的明文和明文对，并从中筛选出符合要求的明文，也能达到选择明文攻击的效果。
选择密文攻击(Chosen Ciphertext Attack)
攻击者能够选择或构造特定的密文，并获取相应的明文，也就是说攻击者能访问解密机。这种情况下，攻击者还可以操纵和分析解密过程，以视图获取解密密钥。
传统密码分析
暴力破解
破解密码的最原始方法是暴力破解，也就是尝试所有可能的密钥。不过这种方式效率很低，只适合密钥空间很小的情况，例如前面讲到的移位密码和仿射密码。
频率分析
对一般的密码，需要分析密文的规律和明文跟密文的关联。这时可以用频率分析之类的统计分析方法。例如，在简单的置换密码和替代密码中，明文字符和密文字符是一一对应的，所以明文的分布规律（英文里不同字母和字母组合出现的概率是不一样的）也会传导给密文，只要分析密文的分布规律，就可以反推得到明文，从而破解密码。
英文字母频率:
E .127
T .091
A .082
O .075
I .070
N .067
S .063
H .061
R .060
...

最常见的两字母组合:
TH,HE,IN,ER,AN,RE,ED,ON,ES,ST,
EN,AT,TO,NT,HA,ND,OU,EA,NG,AS,
OR,TI,IS,ET,IT,AR,TE,SE,HI,OF.

最常见的三字母组合:
THE, ING, AND, HER, ERE, ENT,
THA, NTH, WAS, ETH, FOR, DTH.

频率分析的过程一般是这样，先找到频率最高的密文字母，如果它的频率显著高于其他字母，就可以假定它对应的明文字母是E，然后继续分析剩余字母。对不确定的情况，可以结合两个或三个字母的组合的频率来进行分析。
信息论
对于更复杂的密码，需要对明文和密文的规律做更深入的分析，这就需要更强有力的分析工具，信息论和香农（第一）定理开始派上用场了。信息论的核心是把不确定性作为度量信息的基础，使得“信息”这个原本比较抽象的概念变成可以定量分析的因素。通过分析加密过程中信息量的变化，我们可以在更本质的层次上去理解加密算法所做的各种变换，从而对密码分析和算法设计提供思想和方法上的指导。
现代分析方法
用信息论的话来说，只要密文有任何的规律，就相当于存在一些信息没有被隐藏好，留下了破解的入口。要想提高破解的难度，就需要尽可能的隐藏信息，减少密文的规律，也就是提高密文的随机程度。所以，好的加密算法需要在满足其它条件的前提下，使密文尽可能显得随机。而密码分析就是要从看上去随机的密文中寻找不够随机的规律和因素，现代分析方法更多的是使用相应的数学工具来分析密文分布的偏差。
在算法层面上最重要的有两种：差分分析和线性分析。
差分分析(Differential Cryptanalysis)
Differential在数学里是指微分，在这里一般翻译成"差分"，不过意思都差不多，是指对明文做小的变化（用XOR来衡量），然后分析密文变化和明文变化的关联规律，从而计算密钥每一位的概率分布，逐步缩小范围，直到最终找到密钥。例如，如果明文中的一个字节发生变化，只会影响到密文的一个字节，那就能用频率分析来破解密码。
差分分析属于选择明文攻击，但如果能收集充分多的明文，可以从中选择满足差分分析要求的明文，这时也适用于已知明文攻击。
差分分析是上世纪80年代提出的，论文作者发现DES算法能够有效抵抗差分分析，而算法经过细微调整后就容易分析得多，说明DES算法在设计时很可能就已经考虑到差分分析。后来IBM公司原DES团队的成员发表论文称IBM早在1974就发现了差分分析，抵抗差分分析也是DES的设计目标之一，不过美国政府为了保持密码分析方面的技术优势，要求IBM对外保密，所以一直没有公开。
线性分析(Linear Cryptanalysis)
线性分析的原理跟线性回归有点像。线性回归是利用统计方法从一堆数据找出两个或多个变量可能存在的线性关系，对两个变量的情况来说，就是用一条平面上的直线去拟合给定的数据集，找到拟合度最理想的线性系数。线性分析则是根据加密算法的实现，选择中间一些步骤的输入位和输出位来定义一个随机变量，然后从收集到的明文和密文数据中来分析这个随机变量的分布，看是否存在统计学意义上的偏差。存在偏差，则说明算法在某些步骤上存在线性因素，从中就可以逐步推测密钥的各个位的值。
另一方面，线性分析跟差分分析本质上差不多，只是分别从宏观和微观的角度入手去解决问题。
对密码设计的影响
从前面差分分析和DES算法的关联可以看出，密码分析跟密码设计就是矛和盾、一体两面的关系。密码分析会针对密码设计中的特点，而密码设计也必须考虑到已知的密码分析方法。例如DES在设计时就考虑到了要抵抗住差分分析。简单的说，新设计的密码算法，必须至少能抵抗足够强度的差分分析和线性分析。
现代加密算法
基本设计思想：混淆(Confusion)、扩散(Diffusion)、随机
从前面的各种密码分析方法可以看出，要想抵抗住分析，从宏观上，密文必须体现出随机性，从微观上，明文的一处微小的局部变化必须体现为密文的全局变化，否则明文和密文就存在一对一的线性关系，容易被破解。也就是说，要把明文打散混淆，不仅屏蔽密文跟明文的关联，还要将变化尽可能扩散。扩散的结果就是达到高耦合的目的，打破加密算法中的线性关系。
所以，加密算法的设计思想跟软件开发的原则正好相反。软件开发强调模块化，模块之间低耦合，模块内部高内聚，模块和代码结构清晰。而加密则是要把各个部分混为一体，使它们高度耦合，牵一发而动全身，让破解者找不到线索。
流密码则是通过生成随机密钥流的方式来达到同样的目的。
柯克霍夫原则(Kerckhoffs’s Principle)
就算被所有人知道系统的运作步骤，密码系统应该仍然是安全的。
简单的说，就是加密算法应该公开，让大家充分的去研究和分析。如果全世界的密码学专家花了很长时间都找不到漏洞，那么这个算法基本上可以被认为是安全的。
这个规则是从实践经验中总结出来的。由于对称加密算法的安全性并不能用数学的方式证明，只能看实际应用中是否能抵抗各种分析和破解，所以对算法保密虽然可以提高破解的难度，但也降低了算法漏洞的透明度，导致漏洞被发现和利用后自己还不知道，后果更严重。
现在不只是算法会公开，而且基本上已经形成了公开选拔密码算法的机制，例如AES/RSA/SHA-3。未来的抗量子计算的加密算法也正在进行公开选拔。
SPN(Substitution-Permutation-Network)
SPN是一种特殊的迭代密码。迭代密码是通过多轮的迭代加密操作来提高混淆和扩散的程度，从而提高加密的强度。SPN中每一轮迭代操作都包括多个Substituion操作(S-Box)和一次Permutation操作(P-Box)。S-Box主要负责实现数据的混淆，它的非线性特性是加密算法的关键，是抵抗线性分析等方法的核心要素。P-Box主要负责变化的扩散，将局部的变化扩散到整个分组，提高抵抗破解的能力。每一轮迭代使用不同的轮密钥，轮密钥都是从加密操作的主密钥衍生得到的。
DES
DES算法是IBM设计的，然后被美国政府选为标准加密算法。它采用的是一种叫做Feistel的迭代分组密码结构，特点是每一轮的迭代操作是相同的，都是将数据块按位重新组合，然后分为左右两部分，计算后将左右两部分交换，作为下一轮计算的输入。
DES的缺点是密钥较短，只有56位，抵抗破解的能力较弱，因此有了3DES，可以使用更长的密钥。不过3DES的计算量较大，效率较低。而且在密钥长度、迭代次数等方面难以扩展，所以有了AES。
AES
AES是美国国家标准与技术研究院（NIST）通过公开选拔挑选出作为国家标准的加密算法。AES的优点有：

足够安全，能很好的抵抗差分分析和线性分析
运算速度快，易于实现，而且适合用硬件电路实现
对内存要求低
密码长度和迭代次数可以扩展

加密模式
加密模式在分组加密中用来对每个分组的数据进行调整，包括填充以提高数据整体的安全性，常用的模式有以下一些：
Electronic Codebook Mode(ECB)
ECB是最简单和最基本的模式，对每个分组使用相同的方式加密，相同的明文数据块会被加密成相同的密文，降低了破解的难度，所以实际应用中很少使用。
Cipher Block Chaining Mode(CBC)
CBC模式中，每个数据块加密时直接使用明文跟上个数据块加密后产生的密文或初始向量进行异或，再与密钥进行加密，得到密文。它的缺点是不利于并行、传递误差、需要初始化向量。
Output Feedback Mode(OFB)
每个数据块加密过程中的中间输出会反馈到下个数据块的加密过程中。缺点跟CBC类似。
Cipher Feedback Mode(CFB)
每个数据块加密产生的密文会反馈到下个数据块的加密过程中。缺点跟CBC类似。
Counter Mode(CTR)
用密钥对输入的计数器加密，然后跟明文异或得到密文。优点是可以并行，避免误差传递问题。缺点是可以针对单个数据块进行攻击。
Counter with CBC-MAC Mode(CCM)
CCM是在CBC和CTR的基础上增加CMAC算法校验，主要是通过MAC校验来解决CTR容易被攻击的问题。
Galois/Counter Mode(GCM)
GCM是在CCM的基础上改用GMAC算法代替CMAC算法，增加了并行化设计，可以提高加密性能，降低时延。
小结
虽然加密模式有很多种，但现在有实用价值的还是CCM和GCM两种。这两种也是TLS 1.3唯二使用的AES加密算法。
总结
对称加密算法的细节很多，这里难以逐一深入讲解，只能介绍一些基础的知识点。感兴趣的同学可以阅读相关的密码学书籍和网上的专题文章。

目录
定义
常用对称加密算法
DES
3DES
AES
PEB
常用对称加密算法的java实现
DES实现
3DES实现
AES实现
PEB实现

定义
原文通过加密秘钥生成密文，密文通过解密秘钥得到原文。

对于加密秘钥和解密秘钥是相同的算法，就叫对称加密算法。
常用对称加密算法
DES
Data Encryption Standard

初代对称加密算法

从98年开始不断被破解，到现在已经完全不具备安全性了。

现在基本没人用了，但很值得学习。

秘钥长度56位
3DES
由于DES算法长度不够，衍生出2重DES算法，3重DES算法，4重DES算法等。

用的最多的是3重DES算法。

3重DES，秘钥长度增加，迭代次数增加。

秘钥长度112或168，默认168。
AES
由于3DES效率有些低，所以又有了AES加密算法。

AES是目前使用最多的对称加密算法。而且至今未被破解。

常用于移动通信系统加密和一些基于SSH协议的软件（SSH Client、secureCRT）。

AES秘钥长度128或192或256，默认128。

额外注意，用JDK的实现中，使用256位秘钥需要获得无政府限制权限文件（美国政府的限制，所以一般场景不用）。
PEB
PBE（password based encryption），基于口令的加密算法。

PBE算法，其实是对之前的AES、DES的包装升级。

口令一般是用户自己创建管理的。为了防止暴力破解，要对口令进行加盐操作。

常用的PEB算法：

PBEWithMD5AndDES，秘钥长度56位

PBEWithMD5AndTripleDES，秘钥长度112、168位，默认168位

PBEWithSHA1AndDESede，秘钥长度112、168位，默认168位

PBEWithSHA1AndRC2_40，秘钥长度40~1024位（8的倍数），默认128位
常用对称加密算法的java实现
DES实现
import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

/**
 * @Author: zhangshuai
 * @Date: 2020-04-22 22:38
 * @Description:
 **/
public class DESTest {
    public static void main(String[] args) throws Exception {
        String name = "hello word";
        String password = getPassword();
//        String password = "1122334455667788";
        System.out.println("秘钥："+password);

        byte[] encrypt = encrypt(name.getBytes(), password);
        String encryptString = Hex.encodeHexString(encrypt);
        System.out.println("秘钥加密后的密文："+encryptString);

        byte[] decodeHex = Hex.decodeHex(encryptString.toCharArray());
        byte[] decrypt = decrypt(decodeHex, password);
        System.out.println("秘钥解密后的明文："+new String(decrypt));
    }

    /**
     * 获取随机秘钥
     */
    public static String getPassword() throws NoSuchAlgorithmException {
        KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
        keyGenerator.init(56);
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] keyEncoded = secretKey.getEncoded();
        return Hex.encodeHexString(keyEncoded);
    }

    /**
     * 加密
     */
    public static  byte[] encrypt(byte[] datasource, String password) {
        try{
            SecureRandom random = new SecureRandom();
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            //密匙工厂
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey securekey = keyFactory.generateSecret(desKey);
            //Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用密匙初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
            //现在，获取数据并加密
            //正式执行加密操作
            return cipher.doFinal(datasource);
        }catch(Throwable e){
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解密
     */
    public static byte[] decrypt(byte[] src, String password) throws Exception {
        // DES算法要求有一个可信任的随机数源
        SecureRandom random = new SecureRandom();
        // 创建一个DESKeySpec对象
        DESKeySpec desKey = new DESKeySpec(password.getBytes());
        // 密匙工厂
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        // 将DESKeySpec对象转换成SecretKey对象
        SecretKey securekey = keyFactory.generateSecret(desKey);
        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, random);
        // 解密
        return cipher.doFinal(src);
    }
}


3DES实现

import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;


public class Test3DES {

    public static void main(String[] args) throws Exception {
        String name = "hello word";
        byte[] password = getPassword();
        System.out.println("秘钥：" + Hex.encodeHexString(password));

        byte[] encrypt = encrypt(name.getBytes(), password);
        String encryptString = Hex.encodeHexString(encrypt);
        System.out.println("秘钥加密后的密文：" + encryptString);

        byte[] decodeHex = Hex.decodeHex(encryptString.toCharArray());
        byte[] decrypt = decrypt(decodeHex, password);
        System.out.println("秘钥解密后的明文：" + new String(decrypt));
    }

    /**
     * 获取随机秘钥
     */
    public static byte[] getPassword() throws NoSuchAlgorithmException {
        KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
        keyGenerator.init(168);
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] keyEncoded = secretKey.getEncoded();
        return keyEncoded;
    }
    
    /**
     * 秘钥转换为DESede专用密钥
     */
    private static Key getSecretKey(byte[] key) {
        try {
            DESedeKeySpec deSedeKeySpec = new DESedeKeySpec(key);
            SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
            Key secretKey = factory.generateSecret(deSedeKeySpec);
            return secretKey;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }
    /**
     * 加密
     */
    public static byte[] encrypt(byte[] datasource, byte[] password) {
        try {
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            // 创建密码器
            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));
            // 初始化为加密模式的密码器
            byte[] result = cipher.doFinal(datasource);// 加密
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }
    /**
     * 解密
     */
    public static byte[] decrypt(byte[] src, byte[] password) {
        try {
            // 实例化
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));
            byte[] result = cipher.doFinal(src);
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }
}


AES实现

import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.NoSuchAlgorithmException;


public class TestAES {
    public static void main(String[] args) throws Exception {
        String name = "hello word";
        byte[] password = getPassword();
        System.out.println("秘钥：" + Hex.encodeHexString(password));

        byte[] encrypt = encrypt(name.getBytes(), password);
        String encryptString = Hex.encodeHexString(encrypt);
        System.out.println("秘钥加密后的密文：" + encryptString);

        byte[] decodeHex = Hex.decodeHex(encryptString.toCharArray());
        byte[] decrypt = decrypt(decodeHex, password);
        System.out.println("秘钥解密后的明文：" + new String(decrypt));
    }

    /**
     * 获取随机秘钥
     */
    public static byte[] getPassword() throws NoSuchAlgorithmException {
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(128);
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] keyEncoded = secretKey.getEncoded();
        return keyEncoded;
    }

    /**
     * 获取专用密钥
     */
    private static Key getSecretKey(byte[] key) {
        try {
            return new SecretKeySpec(key, "AES");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 加密
     */
    public static byte[] encrypt(byte[] datasource, byte[] password) {
        try {
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            // 创建密码器
            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));
            // 初始化为加密模式的密码器
            byte[] result = cipher.doFinal(datasource);// 加密
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 解密
     */
    public static byte[] decrypt(byte[] src, byte[] password) {
        try {
            // 实例化
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));
            byte[] result = cipher.doFinal(src);
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

PEB实现

import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import java.security.Key;
import java.security.SecureRandom;


public class TestPBE {
    public static void main(String[] args) throws Exception {
        String name = "hello word";
        String password = "123456";
        System.out.println("秘钥：" + password);

        PBEParameterSpec salt = getSalt();

        byte[] encrypt = encrypt(name.getBytes(), password, salt);
        String encryptString = Hex.encodeHexString(encrypt);
        System.out.println("秘钥加密后的密文：" + encryptString);

        byte[] decrypt = decrypt(encrypt, password, salt);
        System.out.println("秘钥解密后的明文：" + new String(decrypt));
    }

    /**
     * 获取专用密钥
     */
    private static Key getSecretKey(String password) {
        try {
            PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
            SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
            return factory.generateSecret(pbeKeySpec);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 获取盐
     */
    private static PBEParameterSpec getSalt() {
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        // 100次加盐迭代
        return new PBEParameterSpec(salt, 100);

    }

    /**
     * 加密
     */
    public static byte[] encrypt(byte[] datasource, String password, PBEParameterSpec salt) {
        try {
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            // 创建密码器
            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password), salt);
            // 初始化为加密模式的密码器
            byte[] result = cipher.doFinal(datasource);// 加密
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * 解密
     */
    public static byte[] decrypt(byte[] src, String password, PBEParameterSpec salt) {
        try {
            // 实例化
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password), salt);
            byte[] result = cipher.doFinal(src);
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

图为 RSA公开密钥算法的发明人,从左到右Ron Rivest, Adi Shamir, Leonard Adleman. 照片摄于1978年
　　 RSA加密算法是最常用的非对称加密算法，CFCA在证书服务中离不了它。但是有不少新来的同事对它不太了解，恰好看到一本书中作者用实例对它进行了简化而生动的描述，使得高深的数学理论能够被容易地理解。我们经过整理和改写特别推荐给大家阅读，希望能够对时间紧张但是又想了解它的同事有所帮助。

　 　RSA是第一个比较完善的公开密钥算法，它既能用于加密，也能用于数字签名。RSA以它的三个发明者Ron Rivest, Adi Shamir, Leonard Adleman的名字首字母命名，这个算法经受住了多年深入的密码分析，虽然密码分析者既不能证明也不能否定RSA的安全性，但这恰恰说明该算法有一定的可信性，目前它已经成为最流行的公开密钥算法。

　　RSA的安全基于大数分解的难度。其公钥和私钥是一对大素数（100到200位十进制数或更大）的函数。从一个公钥和密文恢复出明文的难度，等价于分解两个大素数之积（这是公认的数学难题）。

　　RSA的公钥、私钥的组成，以及加密、解密的公式可见于下表：



　　可能各位同事好久没有接触数学了，看了这些公式不免一头雾水。别急，在没有正式讲解RSA加密算法以前，让我们先复习一下数学上的几个基本概念，它们在后面的介绍中要用到：

一、什么是“素数”？
　　素数是这样的整数，它除了能表示为它自己和1的乘积以外，不能表示为任何其它两个整数的乘积。例如，15＝3＊5，所以15不是素数；又如，12＝6＊2＝4＊3，所以12也不是素数。另一方面，13除了等于13＊1以外，不能表示为其它任何两个整数的乘积，所以13是一个素数。素数也称为“质数”。

二、什么是“互质数”（或“互素数”）？
　　小学数学教材对互质数是这样定义的：“公约数只有1的两个数，叫做互质数。”这里所说的“两个数”是指自然数。

　　判别方法主要有以下几种（不限于此）：

（1）两个质数一定是互质数。例如，2与7、13与19。

（2）一个质数如果不能整除另一个合数，这两个数为互质数。例如，3与10、5与 26。

（3）1不是质数也不是合数，它和任何一个自然数在一起都是互质数。如1和9908。

（4）相邻的两个自然数是互质数。如 15与 16。

（5）相邻的两个奇数是互质数。如 49与 51。

（6）大数是质数的两个数是互质数。如97与88。

（7）小数是质数，大数不是小数的倍数的两个数是互质数。如 7和 16。

（8）两个数都是合数（二数差又较大），小数所有的质因数，都不是大数的约数，这两个数是互质数。如357与715，357=3×7×17，而3、7和17都不是715的约数，这两个数为互质数。等等。

三、什么是模指数运算？
　　指数运算谁都懂，不必说了，先说说模运算。模运算是整数运算，有一个整数m，以n为模做模运算，即m mod n。怎样做呢？让m去被n整除，只取所得的余数作为结果，就叫做模运算。例如，10 mod 3=1；26 mod 6=2；28 mod 2 =0等等。

　　模指数运算就是先做指数运算，取其结果再做模运算。如

　　好，现在开始正式讲解RSA加密算法。

算法描述：

（1）选择一对不同的、足够大的素数p，q。

（2）计算n=pq。

（3）计算f(n)=(p-1)(q-1)，同时对p, q严加保密，不让任何人知道。

（4）找一个与f(n)互质的数e，且1<e<f(n)。

（5）计算d，使得de≡1 mod f(n)。这个公式也可以表达为d ≡e-1 mod f(n)

这里要解释一下，≡是数论中表示同余的符号。公式中，≡符号的左边必须和符号右边同余，也就是两边模运算结果相同。显而易见，不管f(n)取什么值，符号右边1 mod f(n)的结果都等于1；符号的左边d与e的乘积做模运算后的结果也必须等于1。这就需要计算出d的值，让这个同余等式能够成立。

（6）公钥KU=(e,n)，私钥KR=(d,n)。

（7）加密时，先将明文变换成0至n-1的一个整数M。若明文较长，可先分割成适当的组，然后再进行交换。设密文为C，则加密过程为：。

（8）解密过程为：。

实例描述：
　　在这篇科普小文章里，不可能对RSA算法的正确性作严格的数学证明，但我们可以通过一个简单的例子来理解RSA的工作原理。为了便于计算。在以下实例中只选取小数值的素数p,q,以及e，假设用户A需要将明文“key”通过RSA加密后传递给用户B，过程如下：
（1）设计公私密钥(e,n)和(d,n)。

令p=3，q=11，得出n=p×q=3×11=33；f(n)=(p-1)(q-1)=2×10=20；取e=3，（3与20互质）则e×d≡1 mod f(n)，即3×d≡1 mod 20。

d怎样取值呢？可以用试算的办法来寻找。试算结果见下表：


　　通过试算我们找到，当d=7时，e×d≡1 mod f(n)同余等式成立。因此，可令d=7。从而我们可以设计出一对公私密钥，加密密钥（公钥）为：KU =(e,n)=(3,33)，解密密钥（私钥）为：KR =(d,n)=(7,33)。
（2）英文数字化。
　　将明文信息数字化，并将每块两个数字分组。假定明文英文字母编码表为按字母顺序排列数值，即：


　　则得到分组后的key的明文信息为：11，05，25。
（3）明文加密

　　用户加密密钥(3,33) 将数字化明文分组信息加密成密文。由C≡Me(mod n)得：

　　因此，得到相应的密文信息为：11，31，16。

（4）密文解密。

　　用户B收到密文，若将其解密，只需要计算M= Cd(mod n),即：

　　用户B得到明文信息为：11，05，25。根据上面的编码表将其转换为英文，我们又得到了恢复后的原文“key”。

　 　你看，它的原理就可以这么简单地解释！

　　当然，实际运用要比这复杂得多，由于RSA算法的公钥私钥的长度（模长度）要到1024位甚至2048位才能保证安全，因此，p、q、e的选取、公钥私钥的生成，加密解密模指数运算都有一定的计算程序，需要仰仗计算机高速完成。

最后简单谈谈RSA的安全性

　 　首先，我们来探讨为什么RSA密码难于破解？

　　在RSA密码应用中，公钥KU是被公开的，即e和n的数值可以被第三方窃听者得到。破解RSA密码的问题就是从已知的e和n的数值（n等于pq），想法求出d的数值，这样就可以得到私钥来破解密文。从上文中的公式：d ≡e-1 (mod((p-1)(q-1)))或de≡1 (mod((p-1)(q-1))) 我们可以看出。密码破解的实质问题是：从Pq的数值，去求出(p-1)和(q-1)。换句话说，只要求出p和q的值，我们就能求出d的值而得到私钥。

　　当p和q是一个大素数的时候，从它们的积pq去分解因子p和q，这是一个公认的数学难题。比如当pq大到1024位时，迄今为止还没有人能够利用任何计算工具去完成分解因子的任务。因此，RSA从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。

　　然而，虽然RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何。

　　此外，RSA的缺点还有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。B)分组长度太大，为保证安全性，n 至少也要 600 bits 以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。因此，使用RSA只能加密少量数据，大量的数据加密还要靠对称密码算法。

对称加密算法：长期有效的加密（上）
本期我们将分为两个章节去探索对称密钥算法，这是无处不在的对称加密，就像星际迷航中的小问题一样。
对称加密算法是实现安全通信的基本过程，是信息安全不可或缺的部分，它可以帮助客户安全地以比光速还快的速度对数据进行加密。

什么是对称算法及其工作原理？

对称算法是对称密钥加密的核心加密功能。它是计算机执行与加密和解密数据有关的特定任务时遵循的一组指令或步骤。

这要怎么理解呢？

我们使用对称加密算法（与加密密钥结合）来完成两个主要任务：

加密：将可读文本（纯文本）转换为不可读的加密文本（密文）；
解密：将密文转换回纯文本。

对称加密算法对加密和解密使用相同的加密密钥。（与使用两个不同密钥的非对称加密算法不同。）

通常，加密算法是基于数学原理的，取决于其设计，其范围可以从非常简单到非常复杂。对于对称加密算法，将它们与单个密钥配对以将可读（明文）数据转换为难以理解的乱码（密文）。然后他们使用相同的密钥将密文解密回纯文本。所有这些都是以确保数据机密性和隐私性的方式完成的。看起来是不是有点拗口？但是非常地酷。

实际上，对称加密算法有几种不同的名称：

·        对称密钥算法，

·        对称加密算法，

·        密钥算法，以及

·        大容量密码。（稍后我们将进一步讨论批量密码。）

通常，加密的目的就是为了加密，这样唯一一个拥有密钥的人才能解密和读取秘密消息。具体的操作可以快速浏览下图：


此示例消息是使用AES 128对称加密算法加密的。这里的目的只是向你展示对称密码术的工作原理。
在上图中，从左向右移动，你将看到以纯文本可读数据开头。一旦将对称加密算法和密钥应用于该数据，它便成为无法读取的密文。解密该消息以解密其含义的方法是使用解密密钥。在对称加密的情况下，解密密钥与用于加密数据的密钥相同。基本上，你两次使用相同的密钥。

对称加密算法实际上是做什么的？

简而言之，对称算法是密码学中的一组指令，它们使用一个密钥来加密和解密数据。这些加密算法和密钥是轻量级的，因为它们旨在提高处理大型数据块或数据流的速度。（这就是为什么对称加密算法被称为批量密码的原因。）

另一方面，非对称密钥算法和密钥是资源的消耗者。密钥需要占用大量的CPU处理资源和时间，还有电池电量以及要执行的带宽。

但是，它非常适合加密公共信道中的小批量数据。非对称密钥交换（稍后将详细讨论）是在哪些不安全的公共渠道中分发密钥的好方法。

这就是为什么人们经常使用对称加密来编码大量数据的原因。

是什么决定了对称加密算法的强度？

你是不是很快发现，并非所有对称算法都是平等创建的。它们的强度会有所不同。那么强度在密码学中到底意味着什么？简单的理解是，加密强度就是黑客破解加密以获取数据访问权的难易程度。当然，具体的答案可能会根据你评估的算法类型而异。但是，总的来说，加密强度通常可以归结为以下几个关键特征：

·        对称密钥的长度，随机性和不可预测性；

·        该算法抵抗或抵抗已知攻击的能力；

·        缺少后门或其他故意漏洞。

对称加密可能有点平衡，因为你需要算法和密钥，这些算法和密钥在计算上既困难又实用，可以以可接受的性能使用。
对称加密算法不能在公共频道中独占鳌头

尽管对称加密算法看起来像是用于所有类型的在线数据加密的最合逻辑的工具，但它并不是那么简单。对称加密也有缺点，尤其是在公共信道上单独使用时。这些弱点以密钥分发和密钥管理问题的形式出现：

·        你需要安全的连接来分发对称密钥；

·        如果你将密钥分发给很多人，那么试图与每个拥有密钥副本的人保持同步，这样可能会有难度。

在使用对称加密时，理想情况下，你和与之通信的人会提前（在将其用于任何数据交换之前）对你的密钥进行排序。这意味着，为了与他人安全地共享对称密钥，你需要亲自与他们会面以将其提供给他们。但是，如果你与要共享的另一方遍布在全国各地，该怎么办？或者，甚至在世界的另一端呢？

在目前的状态，人们每天每一刻都在与世界各地的Web服务器交换信息。这意味着人们无法提前见面分发或接收钥匙。因此，我们必须依靠其他方式与其他对接方安全地交换密钥。

这就是非对称算法（或更具体地说，是密钥交换协议）发挥作用的地方。非对称密钥交换使在不安全的公共通道中交换对称密钥成为可能。你可能意识到或还未意识到的是，你现在实际上正在使用对称和非对称加密技术的这种组合。

非对称技术使互联网上的安全对称加密成为可能

给大家看一个网站连接案例。在浏览器中看到那个挂锁图标了吗？有这个图标显示，说明你连接到的网站是安全的。

因此，当我们最初连接mesign.com时，我们的浏览器必须与mesign的服务器执行称为TLS握手的过程。这种握手是服务器向浏览器证明它是合法的而不是冒名顶替者的一种方式。握手过程使用非对称加密和非对称密钥交换过程。
·        非对称加密过程会验证数字签名。

·        非对称密钥交换过程会加密浏览器和Web服务器将用来创建对称会话密钥的主密钥。

当然，握手有几个版本-TLS 1.0，TLS 1.2，TLS 1.3-并且它们的工作方式存在特定差异。（例如，互联网工程任务组[IETF]要求严格使用TLS 1.3中的仅前向安全密码，当然这个话题我们不在这里展开讨论。）但要知道，应该至少要使用TLS1.2握手。截至2020年10月，Qualys SSL Labs报告称99％的站点支持TLS 1.2协议，而39.8％的站点支持TLS 1.3协议。
我们不会在这里详细介绍TLS握手的工作原理，但是我们得它涉及密码套件的使用。这些密码组合通过确定使用以下几种方式，建立安全的HTTPS连接：

·        协议（TLS）

·        非对称密钥交换算法（例如Diffie-Hellman）

·        批量加密密码

·        数字签名

·        哈希函数（例如SHA2-2）

·        消息验证码（MAC）功能

两种对称算法（密码）
在安全地连接到网站时进行对称加密的过程中，我们通过使用批量密码来实现。批量密码有两个子类别：分组密码和流密码。

分组密码

在这种类型的密码中，明文数据分为固定长度的位组（称为块），然后将每个块作为一个单元进行加密，这会使此过程变慢。如果没有足够的数据来完全填充一个块，则使用“填充”（通常商定的0位数）来确保这些块满足固定长度要求。

理想的分组密码具有很大的密钥长度，这是不切实际的，因此许多现代密码必须缩减密钥的长短度才能使用。但请注意：与非对称加密不同的是，对称加密密钥的大小并不能决定数据块的大小。

大多数现代对称加密算法都属于块密码阵营，并且这些类型的密码具有更广泛的用途和应用机会。因此，我们主要在这里重点介绍它们。还有最流行或最常用的流密码是什么，接着我们来讲。

流密码

使用这种类型的密码，它一次加密一位明文数据。这样，数据将在流之中而不是像块密码那样按块进行处理。这使该过程的资源消耗更少，并且可以更快地实现。

现在，我们将不讨论分组密码和流密码的所有细节，未来几周的时间内可能会出分解分组密码和流密码的文章，到时候再来留意吧。

说到这里，可能有人觉得兴奋，有人却开始觉得复杂。使用共享密钥加密时，有几种众所周知的对称密钥算法需要知道。让我们彻底解析它们，以了解它们是什么以及它们是如何工作的。（下文见）