1.       什么是对称式加密和非对称式加密
对称式加密：解密方式是加密方式的逆运算，即加密和解密使用的是同一个密钥（初等加密算法）。
非对称式加密：加密和解密需要两个密钥进行，这两个密钥是公钥和私钥（高等加密算法）。
2.       对称式加密和非对称式加密的主要实现方式
对称式加密主要实现方式：
1）  DES（Data Encryption Standard）：安全性较差，一般不建议使用。
2）  3DES：三重DES，针对DES密钥长度较短的问题，3DES可以实现最少112位、最高168位密钥长度。
3）  AES：相比于3DES拥有更好的安全性。
4）  PBE（Password Based Encryption）：基于口令的加密，结合了DES和AES的优点。
非对称式加密主要实现方式：
1）  DH（Diffie-Hellman）：密钥交换算法。
2）  RSA：基于因子分解。
3）  ElGamal：基于离散对数。
4）  ECC（Elliptical Curve Cryptography）：椭圆曲线加密。
3.       对称式加密和非对称式加密的对比
非对称加密与对称加密相比，其安全性更好：对称加密的通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步密钥。
4.       对称式加密在JAVA中的实现（PBE加密）：

public class PBE {
    private static String src="security with PBE";
    public static void main(String[] args){
        jdkPBE();
    }

    public static void jdkPBE(){
        try {
            //初始化盐（扰码）
            SecureRandom random=new SecureRandom();
            byte[] salt=random.generateSeed(8);

            //口令与密钥
            String password="CSDN";
            PBEKeySpec pbeKeySpec=new PBEKeySpec(password.toCharArray());
            SecretKeyFactory factory=SecretKeyFactory.getInstance("PBEWITHMD5andEDS");
            Key key=factory.generateSecret(pbeKeySpec);

            //加密
            PBEParameterSpec pbeParameterSpec=new PBEParameterSpec(salt,100);//参数1.盐，参数2.迭代次数
            Cipher cipher=Cipher.getInstance("PBEWITHMD5andEDS");
            cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
            byte[] result=cipher.doFinal(src.getBytes());
            System.out.println("jdk pbe encrypt:" + Base64.encodeToString(result,1));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,key,pbeParameterSpec);
            result=cipher.doFinal(result);
            System.out.println("jdk pbe decrypt:"+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
5.      非对称式加密在JAVA中的实现（DH加密）：

public class DH {
    private static String src="security with DH";
    public static void main(String[] args){
        jdkDH();
    }

    public static void jdkDH(){
        try {
            //初始化发送方密钥
            KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();
            byte[] senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();

            //初始化接收方密钥
            KeyFactory receiverKeyFactory=KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);
            PublicKey receiverPublicKey=receiverKeyFactory.generatePublic(x509EncodedKeySpec);
            DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
            KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair();
            PrivateKey receiverPrivateKey=receiverKeyPair.getPrivate();
            byte[] receiverPublicKeyEnc =receiverKeyPair.getPublic().getEncoded();

            //密钥构建
            KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
            receiverKeyAgreement.init(receiverPrivateKey);
            receiverKeyAgreement.doPhase(receiverPublicKey, true);
            SecretKey receiverDesKey=receiverKeyAgreement.generateSecret("DES");

            KeyFactory senderKeyFactory=KeyFactory.getInstance("DH");
            x509EncodedKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
            PublicKey senderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);
            KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");
            senderKeyAgreement.init(senderKeyPair.getPrivate());
            senderKeyAgreement.doPhase(senderPublicKey, true);
            SecretKey senderDesKey=senderKeyAgreement.generateSecret("DES");
            if(Objects.equals(receiverDesKey,senderDesKey)){
                System.out.println("双方密钥相同");
            }

            //加密
            Cipher cipher=Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);
            byte[] result=cipher.doFinal(src.getBytes());
            System.out.println("jdk dh encrypt:"+Base64.encodeToString(result,1));

            //解密
            cipher=Cipher.getInstance("DES");
            cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);
            result=cipher.doFinal(result);
            System.out.println("jdk dh encrypt:"+new String(result));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


6.      非对称式加密在JAVA中的实现（RSA加密）：
public class RSA {
    private static String src="security with rsa";
    public static void main(String[] args){
        jdkRSA();
    }

    public static void jdkRSA(){
        try {
            //初始化密钥
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(512);//64的整倍数，512~65536
            KeyPair keyPair=keyPairGenerator.generateKeyPair();
            RSAPrivateKey rsaPrivateKey= (RSAPrivateKey) keyPair.getPrivate();
            RSAPublicKey rsaPublicKey= (RSAPublicKey) keyPair.getPublic();
            System.out.println("Public key:"+ Base64.encodeToString(rsaPrivateKey.getEncoded(),1));
            System.out.println("Private key:"+ Base64.encodeToString(rsaPrivateKey.getEncoded(),1));

            //私钥加密，公钥解密——加密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory=KeyFactory.getInstance("RSA");
            PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Cipher cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            byte[] result=cipher.doFinal(src.getBytes());
            System.out.println("私钥加密，公钥解密——加密:"+Base64.encodeToString(result,1));

            //私钥加密，公钥解密——解密
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE,publicKey);
            result=cipher.doFinal(result);
            System.out.println(new String(result));

            //公钥加密，私钥解密——加密
            x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,publicKey);
            result=cipher.doFinal(src.getBytes());
            System.out.println("钥加密，私钥解密——加密:"+Base64.encodeToString(result,1));

            //公钥加密，私钥解密——解密
            pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE,privateKey);
            cipher.doFinal(result);
            System.out.println("公钥加密，私钥解密——解密:" + Base64.encodeToString(result, 1));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

基础密码学

在密码算法中，金钥(key)是不可或缺的重要部分，在密码算法中的金钥指的是，203554728568477650354673080689430768这种非常庞大的数字。无论执行加密或解密，都需要有金钥。
依照金钥的用法分为对称式密码与非对称式密码。对称式密码是指用同一把金钥加密和解密。非对称式密码需要两个金钥，一个是公开密钥，另一个是私有密钥；公钥作加密，私钥作解密。公钥可以公开，可任意向外发布；私钥不可以公开，必须由用户自行严格秘密保管，绝不透过任何途径向任何人提供，也不会透露给被信任的要通讯的另一方。
私钥与公钥是如何产生的？

比特币中的私钥是使用SHA-256算法生成32 bytes位元（256 bits）的随机数，这个随机数的作用就相当于”密码”，能够证明对该比特币地址的全部资金所有权及控制权。
比特币中的公钥是基于私钥对应生成的，私钥经过「椭圆曲线加密算法」后所产生的一组乱数。「椭圆曲线密码学」的算法为不可逆，也就是说，即使「公钥」暴露，也不会影响「私钥」的安全性，因为没办法藉由「公钥」推算出「私钥」。公钥主要用于对整个网络中的节点验证交易的有效性。
私钥与公钥是成对产生的，世界上只会有一组，不会重复。
比特币钱包地址是如何产生的？

取得公钥后，将公钥经过两次杂凑函数转换为「公钥杂凑值」，这过程是不可逆的，之后再将「公钥杂凑值」经过BASE58编码推算得到钱包地址。钱包地址像这样：3E1yP8eO5Wkaib7DRPsfTN9Xlmu1CizfQg。地址的功能是接收比特币，某个地址收到比特币后， 只有拥有该地址对应「私钥」的人才能使用它。

加密算法的分类

    1）不可逆加密算法

    2）可逆加密算法

           可逆加密算法又分为两大类：“对称式”和“非对称式”。


非对称加密算法与对称加密算法的区别


    首先，用于消息解密的密钥值与用于消息加密的密钥值不同;

    其次，非对称加密算法比对称加密算法慢数千倍，但在保护通信安全方面，非对称加密算法却具有对称密码难以企及的优势。



des  可逆  对称

rsa  可逆  不对称Elgamal


MD5  不可逆  不对称



    不可逆加密算法的特征是加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，只有重新输入明文，并再次经过同样不可逆的加密算法处理，得到相同的加密密文并被系统重新识别后，才能真正解密。


在计算机网络中应用较多不可逆加密算法的有“RSA公司”发明的MD5算法和由美国国家标准局建议的不可逆加密标准SHS(Secure Hash Standard:安全杂乱信息标准)等。


非对称具体算法

RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）。

使用最广泛的是RSA算法，Elgamal是另一种常用的非对称加密算法。


对称具体算法

DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法。

一、前言

在了解加密原理前，我们来看看这样一个故事。

小红和小明是情侣，一天，小红给小明发短信说：“亲爱的，我银行卡上没有钱了，你给我转1万块吧。”有过上当受骗经历的人都知道这有可能是小偷偷了小红手提包，然后拿手机发的短信。不过我们小明学过加密原理，于是他回复说：“你直接拿我的银行卡刷吧，密码加上我们第一次约会的日期就是663156。”很明显，只有小明和小红知道他们第一次约会是什么时候，假设是2008年4月1号，那么小红就可以根据计算663156-200841=462315得到银行卡密码，就可以消费了。

这就是加密的本质，将信息与密钥相加得到加密后的信息。只有知道密钥的人才能解密。

二、什么是秘钥

既然加密需要密钥，那么密钥是什么呢？

密钥是作用于加密时的一串密码，通过密钥进行信息加密，传输，到达接收者和监听者，由于接收者也有密钥，所以接收者可以根据密钥进行解密。从而防止通讯信息泄露。

三、什么是对称加密

前言讲的故事就是一个对称式加密，小明和小红都知道第一次约会的日期。所以传统的对称式加密需要通讯双方都保存同一份密钥，通过这份密钥进行加密和解密。所以非对称加密也称为单密钥加密。

对称加密的优势在于加解密速度快，但是安全性较低，密钥一旦泄露，所有的加密信息都会被破解。同时密钥的传输和保密也成为难题。为了解决密钥传输的问题，出现通过密钥交换建立共享密钥的技术。具体如何建立共享密钥呢？我们往下看。

3.1 建立共享密匙

在小明、小红和小偷的三人世界中，由于小明是学过加密原理的，知道迪菲–赫尔曼密钥交换（Diffie-Hellman Key Exchange），所以他知道如何建立共享密钥。

3.1.1 颜料混合把戏：

接下来我们看看如何通过颜料混合把戏建立共享密钥吧。

假设在房间中有小明、小红和小偷三个人，每个人各自拥有相同颜色的颜料。在房间的正中间也有这些颜料。接下来，小明要和小红建立共享密钥了。此时，小明对大家说：“我要用蓝色。”然后小明从自己的颜料里选择了黄色，这个黄色就是小明的私钥，小红和小偷都不知道。小明将自己的私钥黄色与公钥蓝色混合后，得到了一种不能分解的颜色，我们就叫“小明-蓝色”吧（虽然大家都知道黄+蓝变绿，但是这里我们为了知道是谁的混合色，还是以名字加公钥颜色来称呼），然后小明将“小明-蓝色”公布了出来。同样，小红听到了小明说用蓝色后，也选择了自己的私钥红色与公钥蓝色混合，得到了“小红-蓝色”并公布了出来。

此时，房间中小明、小红、小偷三人都知道了几个信息。


1.他们都用了蓝色

2.小明公布了“小明-蓝色”（小红和小偷不知道是什么颜料与蓝色的混合）

3.小红公布了“小红-蓝色”（小红和小偷不知道是什么颜料与蓝色的混合）


接下来，见证奇迹的时刻到了，小明拿到“小红-蓝色”与自己的私钥“黄色”混合，得到“小红-蓝色-小明”的新颜料。同样的，小红拿到“小明-蓝色”与自己的私钥“红色”混合，得到“小明-蓝色-小红”。大家发现了吗？“小红-蓝色-小明”和“小明-蓝色-小红”是一模一样的颜色。而小偷不知道小明和小红的私钥颜色，无法混合出与他们相同的颜色。

至此，共享密钥建立起来了。在了解了共享密钥的建立过程后，我们将告别实体颜料，采用数字的方式来建立共享密钥。

**注：**大家可能想到了，小偷可以根据自己的颜料与公钥“蓝色”混合，尝试得出“小明-蓝色”和“小红-蓝色”。这样的方法称之为穷举法，也就是尝试所有的可能性，进行信息破解，所以加密算法在理论上都是可以通过穷举法破解的，只不过实际上，超级计算机都需要计算万亿年才能穷举出所有可能性。

3.1.2 乘法把戏：

首先，我们假设乘法如同颜料混合一样，是不能分解的，看看如何用乘法与数字建立共享密钥。

小明公开了一个数字5，然后小明选择了一个私人数字4，然后利用乘法将两者混合起来，得到“小明-5”（20），接下来小红也选择了一个私人数字7得到“小红-5”（35），小明拿到35*4=140，小红拿到20*7=140。共享密钥建立完成。

大家也发现了，小偷知道20,35,5这三个数字后，用除法就能算出小明和小红的私钥。所以，接下来我们将了解实际使用中的如何使用乘法把戏来防止私钥被计算出来的。

3.2 迪菲–赫尔曼密钥交换算法

我们都知道幂运算，但是要让计算机计算就比较难了。所以，我们会用幂运算作为建立共享密钥的乘法把戏。同时，我们还要了解钟算的原理，这里的钟可以理解成我们经常看到的时钟，我们常见的时钟最大是12，如果当前是10点，过了4个小时后，就变成了下午2点。也就是(10+4)mod12=2。了解了钟算和幂运算后，就开始进入正题吧。

还是小明、小红和小偷的房间，小明声明了钟为11，幂运算的底为2，接下来小明和小红分别选择了自己的私钥4和7。


第一步，小明混合自己的“小明-11,2”得到，小红混合自己的“小红-11,2”得到。

第二步，小明拿到“小红-11,2”（7）进行计算，小红拿到“小明-11,2”（5）进行计算。


大家注意到了吗，小明和小红建立了共享密钥3，而小偷无法根据已知的11,2,5,7这几个数字计算出密钥或小明小红的私钥。有了共享密钥后，小明和小红就可以安全进行加密传输了。



3.3 AES对称加密过程

AES 的全称是 Advanced Encryption Standard ，是最流行的对称加密算法，其加解密速度快。AES支持128位，192位，256位三种长度的密钥，密钥越长安全性越高。AES加密时会把明文切分成许多小块的明文，然后对每块明文单独加密，将加密后的密文传送出去，接收方再将密文切块解密，得到明文。

如下图所示：



上一步中小明和小红已经协商好了密钥3。接下来就可以通过对称加密进行通信了。

在小明、小红和小偷的房间中，小明想把密码“462315”告诉小红，于是：


第一步：将密码按照一位的长度进行切分（实际中通常按128位进行切分）；就变成了“4”“6”“2”“3”“1”“5”；

第二步：对每块明文通过密钥3进行加密，结果就是“795648”，然后小明告诉小红和小偷：“我的密码是795648”；

第三步：小红拿到密文后，对密文进行切块，对每块通过密钥3进行解密，就得到了正确的密码“462315”，而小偷由于不知道密钥，就无法解密出正确的信息。


四、什么是非对称加密

在对称加密中，加密和解密使用的是同一份密钥。所以，在非对称加密中，加密和解密使用的是不同的密钥。非对称加密中的密钥分为公钥和私钥。公钥顾名思义就是公开的，任何人都可以通过公钥进行信息加密，但是只有用户私钥的人才能完成信息解密。非对称加密带来了一个好处，避免了对称式加密需要传输和保存同一份密钥的痛苦。

现在最流行的非对称加密算法就是RSA加密算法，具体是怎么做的呢，我们继续往下看。

4.1 AES对称加密过程

维基百科是这么解释的：RSA加密算法是一种非对称加密算法，在公开密钥加密和电子商业中被广泛使用。RSA是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年一起提出的。当时他们三人都在麻省理工学院工作。RSA 就是他们三人姓氏开头字母拼在一起组成的。

前面我们讲了如何通过钟算和幂函数建立不可逆（计算机可以通过穷举法计算出私钥，实际场景中就算是超级计算机也要计算几万亿年之久）的共享密钥。由于小红是小明的女朋友，小明天天在小红面前给她讲RSA加密算法的原理，所以小红也知道怎么得出自己的公钥和私钥。接下来我们一起跟着小红的脚步，看看RSA加密的公钥和私钥是怎么计算出来的。


第一步：小红选择了两个很大的质数p和q，这里为了便于计算，选择2和11;

第二步：计算p和q的乘积n=p*q=2*11=22；

第三部：计算n的欧拉函数φ(n)=(p-1)*(q-1)=10；

第四步：选择一个小于φ(n)且与φ(n)互质的整数e，{1,3,7,9}，这里选择e=7；

第五步：计算e对于φ(n)的模反元素（ed mode φ(n) = 1）d，d=3


到这里小红就得到了他自己的公钥(n,e)和私钥(n,d)。其中n就是钟大小，e和d就是幂函数的幂。接下来就通过计算出来的公钥和私钥进行数据的加解密。

还是小明、小红和小偷三个人，小红对大家说，我的公钥是（22,7），小明知道了小红的公钥后，想讲自己的信息“14”告诉小红，于是就用小红公开的公钥进行加密。

具体步骤如下：


第一步：小明根据要加密的信息14进行计算，得到加密后的信息20，然后将20告诉小红和小偷；

第二步：小红有自己的私钥，将加密信息20进行解密，，得到了小明想传递给小红的信息。而小偷呢，知道22,7,20，但是不知道小红的密钥（22,3），无法解密出正确的信息。


RSA加密算法在数字签名中也发挥着巨大的作用，假设小偷可以假冒小红，说小红的公钥是（22,9），而小明不知道是小偷假扮的，按照小偷的公钥加密后，结果被小偷解密了。数字签名的作用就是防止信息被篡改，小红说她的公钥是（22,7）的同时，使用私钥给这段信息（通常使用MD5值计算签名）加上签名，小明得到公钥（22,7）和签名13，小明拿到签名后利用公钥计算出信息是否被篡改。



五、加密的实际作用

本文使用的很小的数来进行加密原理的讲解，为了是读者可以方便进行计算。在实际使用中（n,e）都是特别大的数，其中n的长度都在768以上，1024长度被认为是基本安全的。

（1230186684530117755130494958384962720772853569595334792197322452151726400507263657518745202199786469389956474942774063845925192557326303453731548268507917026122142913461670429214311602221240479274737794080665351419597459856902143413=
 
33478071698956898786044169848212690817704794983713768568912431388982883793878002287614711652531743087737814467999489
 
×
 
36746043666799590428244633799627952632279158164343087642676032283815739666511279233373417143396810270092798736308917）

复制代码

六、总结

最后总结一下，首先我们通过一个诈骗短信的例子，引出了加密的原理就是信息+密钥，密钥就是对信息进行加解密的一串数字。然后通过颜料混合把戏形象的演示了如何建立共享密钥。在使用乘法建立共享密钥的过程中，学习了钟算和幂运算，接着我们了解了RSA加密算法的过程，通过两个质数生成公钥和私钥，最后，我们根据公钥进行信息加密，再通过私钥完成信息解密。

七、写在最后

或许看到这里，大家心里还有许多疑惑。为什么小明和小红建立共享密钥时，通过几次幂运算和钟算就能得到一样的共享密钥？为什么RSA加密算法要用两个质数？为什么通过公钥加密的信息可以通过私钥解开？

加密算法的背后，是一道道迷人的数学难题，而RSA加密算法之所以被广泛运用，是因为一个名为整数分解的古老数学问题，你可以轻易找到两个很大的质数相乘得到一个结果n，但是要将这个结果n分解回两个质数就变得极其困难。尽管这个所谓的“整数分解”问题被研究了数个世纪，还没人能找到一个足够高效的通用方法解决它，并对标准RSA钟大小造成危害。

数学史中充满了未解决的问题，尽管这些迷人的问题缺乏任何实际应用，却单靠其美学特质就吸引了数学家进行深入探究。令人颇感惊讶的是，许多这类迷人但显然无用的问题后来都有了很大的实用价值，这一价值只有在问题被研究数个世纪后才得以破解。整数分解这一问题由来已久。对其最早的严肃研究似乎是在17世纪，由数学家费马（Fermat）和梅森（Mersenne）进行的。欧拉（Euler）和高斯（Gauss）两位数学“泰斗”也在接下来的世纪里对这一问题做出了贡献。但直到公钥加密于20世纪70年代被发明，分解大数字的困难才成为一个实际应用的关键。


作者：vivo 互联网服务器团队-Deng Qian


推荐阅读

为什么阿里巴巴的程序员成长速度这么快？

进大厂也就这回事，工作2到3年后进大厂操作指南

阿里架构师【柏羲】带你揭秘架构项目实战与源码解读：微博+B站架构设计、JUC核心、Mybatis源码

看完三件事

如果你觉得这篇内容对你还蛮有帮助，我想邀请你帮我三个小忙：

点赞，转发，有你们的 『点赞和评论』，才是我创造的动力。

关注公众号 『 Java斗帝 』，不定期分享原创知识。

同时可以期待后续文章ing🚀