对称加密算法和非对称加密算法的区别
 
1.对称加密算法加密和解密使用的密钥的是相同的，也就是只有一个密钥，而非对称加密算法有两个密钥，也就是加密和解密所使用的密钥是不同的

 2.各自算法不同

 3.对称加密算法加密速度快（相对的），非对称算法，密钥成对生成，公钥对外发布，但是对大数据的加解密速度比对称算法慢。

 4.还有就是安全性不同，对称加密算法，在传输的过程中被窃听那就玩完了，而非对称加密算法就可以很好的避免这个问题

 5.数字签名，对称加密不可以用于数字签名和数字鉴别，非对称加密可以用于数字签名和数字鉴别。
 
对称加密算法与非对称加密算法的相同点
 
废话一句：都是加密算法

 咳咳…

 1.都是可逆的

 2.然后…

 然后…

 emm

 暂时没有想到
 
对称加密算法和非对称加密算法的优缺点
 
对称加密算法：速度快但是安全性不可保证、安全性取决于密钥的长度、对称加密算法是可逆的、占用的资源空间较少、源认证存在问题

 非对称加密算法：安全性高但是速度慢、非对称加密算法压缩可逆、占用运算空间资源较多、源认证存在问题
 
常见的算法
 
对称加密算法：DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK、AES等等

 非对称加密算法：RSA、Elgamal、背包算法、Rabin、D-H、ECC等等

 ps：

 ECC：椭圆曲线加密算法
 
其他链接
 
哔哩哔哩
 会同步该博客发一些自制视频
 
微博
 用的比较少
 
Github
 一些源代码
 
知乎
 不懂的我一般会在上面提问
 
简书
 同步该博客内容相同
 
CSDN
 同步该博客内容相同
 博客首页
 
个人联系方式
 
QQ：2446264712
 
微信：X15019749137
 
邮箱：xiaoyangaichibaozi@yeah.net
 
有意添加请备注 啊啊啊啊

对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。不足之处是，交易双方都使用同样钥匙，安全性得不到保证。此外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的惟一钥匙，这会使得发收信双方所拥有的钥匙数量成几何级数增长，密钥管理成为用户的负担。对称加密算法在分布式网络系统上使用较为困难，主要是因为密钥管理困难，使用成本较高。假设两个用户需要使用对称加密方法加密然后交换数据，则用户最少需要2个密钥并交换使用，如果企业内用户有n个，则整个企业共需要n×(n-1) 个密钥，密钥的生成和分发将成为企业信息部门的恶梦。对称加密算法的安全性取决于加密密钥的保存情况，但要求企业中每一个持有密钥的人都保守秘密是不可能的，他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得，入侵者便可以读取该用户密钥加密的所有文档，如果整个企业共用一个加密密钥，那整个企业文档的保密性便无从谈起。 .Net中支持的对称加密算法主要有:DES,RC2,Rijndael,TripleDES。 非对称加密算法使用两把完全不同但又是完全匹配的一对钥匙—公钥和私钥。在使用非对称加密算法加密文件时，只有使用匹配的一对公钥和私钥，才能完成对明文的加密和解密过程。加密明文时采用公钥加密，解密密文时使用私钥才能完成，而且发信方（加密者）知道收信方的公钥，只有收信方（解密者）才是唯一知道自己私钥的人。非对称加密算法的基本原理是，如果发信方想发送只有收信方才能解读的加密信息，发信方必须首先知道收信方的公钥，然后利用收信方的公钥来加密原文；收信方收到加密密文后，使用自己的私钥才能解密密文。显然，采用非对称加密算法，收发信双方在通信之前，收信方必须将自己早已随机生成的公钥送给发信方，而自己保留私钥。由于非对称算法拥有两个密钥，因而特别适用于分布式系统中的数据加密。如果企业中有n个用户，企业需要生成n对密钥，并分发n个公钥。由于公钥是可以公开的，用户只要保管好自己的私钥即可，因此加密密钥的分发将变得十分简单。同时，由于每个用户的私钥是唯一的，其他用户除了可以可以通过信息发送者的公钥来验证信息的来源是否真实，还可以确保发送者无法否认曾发送过该信息。非对称加密的缺点是加解密速度要远远慢于对称加密，在某些极端情况下，甚至能比非对称加密慢上1000倍。广泛应用的不对称加密算法有RSA算法和美国国家标准局提出的DSA。 .Net中支持的非对称加密算法主要有:DSA,RSA。 Hash算法(哈希值) Hash算法特别的地方在于它是一种单向算法，用户可以通过Hash算法对目标信息生成一段特定长度的唯一的Hash值，却不能通过这个Hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。 .Net中支持的Hash算法主要有:HMACSHA1,MACTripleDES,MD5,SHA1,SHA256,SHA384,SHA512。

目录
 
简介
 
密码常用术语
 
密码分类——时间
 
密码分类——保密内容算法
 
密码分类——密码体制
 
密码分类——明文处理方法
 
散列函数
 
特点：
 
散列函数相关的算法
 
数字签名
 
OSI安全体系
 
Java安全组成
 
相关Java包、类
 
第三方java扩展
 
Base64算法
 
算法实现方式：
 
三种实现方式代码实现：
 
应用场景：
 
对称加密算法——DES
 
实现方：
 
主要流程：
 
 代码实现：
 
对称加密算法——3重DES
 
3重DES的好处：
 
3重DES的缺点：
 
实现方：
 
代码实现：
 
 对称加密算法——AES
 
主要流程：
 
代码实现：
 
 对称加密算法——PBE
 
实现方：
 
主要流程：
 
​代码实现：
 
 非对称加密算法——DH（密钥交换）
 
实现方：
 
 主要流程
 
代码实现：
 
可能会出现的问题：
 
 问题解决：
 
非对称加密算法——RSA
 
实现方：
 
主要流程：
 
 代码实现：
 
 非对称加密算法——ElGamal
 
实现方：
 
主要流程：
 
​ 代码实现：
 

简介
 
本文章是作者在闲时去了解的加密算法的使用，也实际的了解了什么是加密算法，以及算法的分类，算法都有哪些，在这里分享给大家。
 
主要包含  Base64算法；对称加密算法——DES、3重DES、AES、PBE；非对称加密算法——DH、RSA、Elgamal。
 
密码常用术语
 
        明文：待加密信息。
 
        密文：经过加密后的明文。
 
        加密：明文转为密文的过程。
 
        加密算法：明文转为密文的转换算法。
 
        加密密钥：通过加密算法进行加密操作用的密钥。
 
        解密：将密文转为明文的过程。
 
        解密算法：密文转为明文的算法。
 
        解密密钥：通过解密算法进行解密操作用的密钥。
 
        密码分析：截获密文者试图通过分析截获的密文从而推断出原来的明文或密钥的过程。
 
        主动攻击：攻击者非法入侵密码系统，采用伪造、修改、删除等手段向系统注入假消息进行欺骗。（对密文具有破坏作用）
 
        被动攻击：对一个保密系统采取截获密文并对其进行分析和攻击。（对密文没有破坏作用）。
 
        密码体制：由明文空间、密文空间、密钥空间、加密算法和解密算法五部分构成。
 
        密码协议：也称安全协议，指以密码学为基础额的消息交换的通信协议，目的是在网络环境中提供安全的服务
 
        密码系统：指用于加密、解密的系统。
 
        柯克霍夫原则：数据的安全基于密钥而不是算法的保密。即系统的安全取决于密钥，对密钥保密，对算法公开。——现代密码学设计的基本原则。
 
密码分类——时间
 
        古典密码：以字符为基本加密单元。
 
        现代密码：以信息块为基本加密单元。
 
密码分类——保密内容算法
 
名称
详细说明
应用领域
类别
受限制算法
算法的保密性基于保持算法的秘密
军事领域
古典密码
基于密钥算法
算法的保密性基于对密钥的保密
现代密码
密码分类——密码体制
 
名称
别名
详细说明
对称密码
单钥密码或私钥密码
指加密密码与解密密码相同
非对称密码
双钥密码或公钥密码
指加密密钥与解密密钥不同，密钥分公钥、私钥
对称密码算法
单钥密码算法或私钥密码算法
指应用于对称密码的加密、解密算法
非对称密码算法
双钥密码算法或公钥密码算法
指对应于非对称密码的加密、解密算法
密码分类——明文处理方法
 
        分组密码：指加密时将名为分成固定长度的组，用同一密钥和算法对每一块加密，输出也是固定长度的密文。多用于网络加密。
 
        流密码：也称序列密码。指加密时每次加密以为或者一个字节明文。
 
散列函数
 
        散列函数用来验证数据的完整性
 
特点：
 
        长度不受限制
 
        哈希值容易计算
 
        散列运算过程不可逆
 
散列函数相关的算法
 
        消息摘要算法MD5等
 
        SHA——安全散列算法
 
        MAC——消息认证码算法
 
数字签名
 
        主要是针对数字的形式存储的消息进行的处理。
 
OSI安全体系
 
        OSI（Open System Interconnection）
 
 
 
 
 
 
 
 
Java安全组成
 
JCA（Java Cryptography Architecture）：Java加密体系结构
 
JCE（Java Cryptography Extension）：Java加密扩展包（DES、AES、RSA算法都是通过JCE提供）
 
JSSE（Java Secure Socket Extension）：Java安全套接字扩展包（JSSE提供基于SSL的加密功能，主要用于网络传输）
 
JAAS（Java Authenticatoin and Authentication Service）：Java鉴别于安全服务
 
相关Java包、类
 
java.security——消息摘要
 
javax.crypto——安全消息摘要，消息认证（鉴别）码
 
java.net.ssl——安全套接字（HttpsURLConnection\SSLContext）
 
第三方java扩展
 
Bouncy Castle——两种支持方案：1）配置 2）调用
 
Commons Codec——Apache、Base64、二进制、十六进制、字符集编码、URL编码/解码
 
Base64算法
 
算法实现方式：
 
        JDK、Commons Codec、Bouncy Castle
 
三种实现方式代码实现：
 
package com.bxl.demo.service;

import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.IOException;

/**
 * Created by xiaobai on 2021-8-24
 */
public class Base64Demo {

    private static String src = "xiaobai base64";

    public static void main(String[] args) {
        jdkBase64();
        commonsCodesBase64();
        bouncyCastleBase64();
    }

    public static void jdkBase64(){
        try {
            BASE64Encoder base64Encoder = new BASE64Encoder();
            String encodeBase64 = base64Encoder.encode(src.getBytes());
            System.out.println("encode:" + encodeBase64);

            BASE64Decoder base64Decoder = new BASE64Decoder();
            byte[] decoderBase64 = base64Decoder.decodeBuffer(encodeBase64);
            System.out.println("decode:" + new String(decoderBase64));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void  commonsCodesBase64(){
        byte[] encodeBase64 = Base64.encodeBase64(src.getBytes());
        System.out.println("encode:" + new String(encodeBase64));

        byte[] decodeBytes = Base64.decodeBase64(encodeBase64);
        System.out.println("decode:" + new String(decodeBytes));
    }

    /**
     * BC算法需要添加依赖bcprov-jdk15on
     * <dependency>
     *     <groupId>org.wso2.orbit.org.bouncycastle</groupId>
     *     <artifactId>bcprov-jdk15on</artifactId>
     *     <version>1.60.0.wso2v1</version>
     * </dependency>
     */
    public static void  bouncyCastleBase64(){
        byte[] encodeBase64 = org.bouncycastle.util.encoders.Base64.encode(src.getBytes());
        System.out.println("encode:" + new String(encodeBase64));

        byte[] decodeBytes = org.bouncycastle.util.encoders.Base64.decode(encodeBase64);
        System.out.println("decode:" + new String(decodeBytes));
    }

}
 
应用场景：
 
        e-mail、密钥、证书文件
 
对称加密算法——DES
 
DES（Data Encryption Standard）数据加密标准（目前不建议使用，因为不安全了）
 
实现方：
 
 
主要流程：
 
 
 代码实现：
 
package com.bxl.demo.service;

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.Key;
import java.security.Security;

/**
 * Created by xiaobai on 2021-8-24
 */
public class DESDemo {

    private static String src = "xiaobai DES";

    public static void main(String[] args) {
        jdkDES();
        bcDES();
    }

    public static void jdkDES(){

        try {
            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
            keyGenerator.init(56);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            // KEY转换
            DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);

            // 加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk des encrypt：" + Hex.encodeHexString(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("jdk des decrypt：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    public static void bcDES(){
        try {
            // 推荐这样使用，而不是修改JDK的配置文件
            Security.addProvider(new BouncyCastleProvider());

            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DES","BC");

            keyGenerator.init(56);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            // KEY转换
            DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);

            // 加密
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk des encrypt：" + Hex.encodeHexString(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("jdk des decrypt：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
 
对称加密算法——3重DES
 
        3DES(Triple DES或DESede)，还有2重DES、4重DES，但是3重DES的实际应用广泛。
 
3重DES的好处：
 
        1.密钥长度增强
 
        2.迭代次数提高
 
3重DES的缺点：
 
        效率低，速度慢
 
实现方：
 
 
代码实现：
 
package com.bxl.demo.service;

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;
import java.security.Key;
import java.security.SecureRandom;
import java.security.Security;

/**
 * Created by xiaobai on 2021-8-24
 */
public class TreeDESDemo {

    private static String src = "xiaobai 3DES";

    public static void main(String[] args) {
        jdkDES();
        bcDESede();
    }

    public static void jdkDES(){

        try {
            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
            //keyGenerator.init(168);
            // SecureRandom生成默认长度的key
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            // KEY转换
            DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
            Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);

            // 加密
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk desede encrypt：" + Hex.encodeHexString(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("jdk desede decrypt：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    public static void bcDESede(){
        try {
            // 推荐这样使用，而不是修改JDK的配置文件
            Security.addProvider(new BouncyCastleProvider());

            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
            //keyGenerator.init(168);
            // SecureRandom生成默认长度的key
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            // KEY转换
            DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DESede");
            Key convertSecretKey = secretKeyFactory.generateSecret(desKeySpec);

            // 加密
            Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk desede encrypt：" + Hex.encodeHexString(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result = cipher.doFinal(result);
            System.out.println("jdk desede decrypt：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
 对称加密算法——AES
 
        比较高级、DES替代者
 
 
主要流程：
 
 
代码实现：
 
package com.bxl.demo.service;

import org.apache.commons.codec.binary.Base64;
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.SecureRandom;

/**
 * Created by xiaobai on 2021-8-24
 */
public class AESDemo {

    private static String src = "xiaobai AES";

    public static void main(String[] args) {
        jdkAES();
    }

    public static void jdkAES(){
        try {
            // 生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            //keyGenerator.init(168);
            // SecureRandom生成默认长度的key
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();

            // KEY转换
            Key key = new SecretKeySpec(bytesKey,"AES");

            // 加密
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,key);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk aes encrypt：" + Base64.encodeBase64String(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE,key);
            result = cipher.doFinal(result);
            System.out.println("jdk aed decrypt：" + new String(result));
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}
 
 对称加密算法——PBE
 
PBE算法结合了消息摘要算法和对称加密算法的优点
 
PBE（Password Based Encryption）基于口令加密
 
对已有算法的包装
 
盐
 
常用的如：PBEWithMD5AndDES
 
实现方：
 
        JDK、BC
 
 
 
主要流程：
 

 代码实现：
 
package com.bxl.demo.service;

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

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;

/**
 * Created by xiaobai on 2021-8-24
 */
public class PBEDemo {

    private static String src = "xiaobai PDE";

    public static void main(String[] args) {
        jdkPDE();
    }

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

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

            // 实例化PDE输入材料
            PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt, 100);

            // 加密
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
            cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk pde encrypt：" + Base64.encodeBase64String(result));

            // 解密
            cipher.init(Cipher.DECRYPT_MODE,key,pbeParameterSpec);
            result = cipher.doFinal(result);
            System.out.println("jdk pde decrypt：" + new String(result));
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}
 
 非对称加密算法——DH（密钥交换）
 
        构建本地密钥
 
实现方：
 
 
 主要流程
 
 
代码实现：
 
package com.bxl.demo.service;

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

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import java.util.Objects;

/**
 * Created by xiaobai on 2021-8-24
 */
public class DHDemo {

    private static String src = "xiaobai DH";

    public static void main(String[] args) {
        jdkDH();
    }

    public static void jdkDH(){
        try {
            // 1.初始化发送方密钥
            KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
            // 发送方公钥，发送给接收方（网络、文件...）
            byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();

            // 2.初始化接收方密钥
            KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
            PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
            // 获取发送方公钥中的参数
            DHParameterSpec dhParameterSpec = ((DHPublicKey)receiverPublicKey).getParams();
            KeyPairGenerator receiverPairGenerator = KeyPairGenerator.getInstance("DH");
            receiverPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeypair = receiverPairGenerator.generateKeyPair();
            PrivateKey receiverPrivateKey = receiverKeypair.getPrivate();
            byte[] receiverPublicKeyEnc = receiverKeypair.getPublic().getEncoded();

            // 3.密钥构建
            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("双方密钥相同！");
            }

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

            // 5.解密
            cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);
            result = cipher.doFinal(result);
            System.out.println("jdk dh decrypt：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
可能会出现的问题：
 
 
 问题解决：
 
        由于JDK版本不同，在Java 8 update 161版本以后就会出现此问题，根本原因还是DH密钥长度至少为512位，而DES算法密钥没有这么长，密钥长度不一致引起的。
 
        配置JVM的系统变量：
 
-Djdk.crypto.KeyAgreement.legacyKDF=true
 
 
非对称加密算法——RSA
 
        唯一广泛接受并实现
 
        数据加密&数字签名
 
        公钥加密、私钥解密
 
        私钥加密、公钥解密
 
实现方：
 
 
主要流程：
 
 
 代码实现：
 
package com.bxl.demo.service;

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

import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * Created by xiaobai on 2021-8-24
 */
public class RSADemo {

    private static String src = "xiaobai rsa";

    public static void main(String[] args) {
        // 执行方法
        jdkRSA();
    }

    public static void jdkRSA(){

        try {
            /* 一、初始化密钥 */
            // 1.获得RSA的KeyPairGenerator对象示例
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            // 2.修改key的长度
            keyPairGenerator.initialize(512);
            // 3.得到KeyPair对象
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 4.获取公钥
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            // 5.获取私钥
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
            System.out.println("Public key:" + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
            System.out.println("Private key:" + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));

            // 2.私钥加密、公钥解密——加密
            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.encodeBase64String(result));

            // 3.私钥加密、公钥解密——解密
            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("私钥加密、公钥解密——解密：" + Base64.encodeBase64String(result));
            System.out.println("私钥加密、公钥解密——解密：" + new String(result));

            // 4.公钥加密、私钥解密——加密
            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.encodeBase64String(result));

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

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


}
 
 非对称加密算法——ElGamal
 
        使用的是公钥加密算法
 
        Bouncy Castle提供
 
实现方：
 
 
主要流程：
 
 代码实现：
 
package com.bxl.demo.service;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * Created by xiaobai on 2021-8-24
 */
public class ElgamalDemo {

    private static String src = "xiaobai Elgamal";

    public static void main(String[] args) {
        // 执行方法
        jdkElgamal();
    }

    public static void jdkElgamal(){

        try {
            // 首先需要添加Provider
            // 公钥加密、私钥解密
            Security.addProvider(new BouncyCastleProvider());

            /* 一、初始化密钥 */
            AlgorithmParameterGenerator algorithmParameterGenerator = AlgorithmParameterGenerator.getInstance("ElGamal");
            algorithmParameterGenerator.init(256);
            AlgorithmParameters algorithmParameters = algorithmParameterGenerator.generateParameters();
            DHParameterSpec dhParameterSpec = algorithmParameters.getParameterSpec(DHParameterSpec.class);
            KeyPairGenerator keyPairGenerator1 = KeyPairGenerator.getInstance("ElGamal");
            keyPairGenerator1.initialize(dhParameterSpec,new SecureRandom());
            KeyPair keyPair = keyPairGenerator1.generateKeyPair();
            PublicKey elGamalPublicKey = keyPair.getPublic();
            PrivateKey elGamalPrivateKey = keyPair.getPrivate();
            System.out.println("Public key:" + Base64.encodeBase64String(elGamalPublicKey.getEncoded()));
            System.out.println("Private key:" + Base64.encodeBase64String(elGamalPrivateKey.getEncoded()));
            
            // 2.公钥加密、私钥解密——加密
            X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(elGamalPublicKey.getEncoded());
            KeyFactory keyFactory = KeyFactory.getInstance("ElGamal");
            PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            Cipher cipher = Cipher.getInstance("ElGamal");
            cipher.init(Cipher.ENCRYPT_MODE,publicKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("公钥加密、私钥解密——加密：" + Base64.encodeBase64String(result));

            // 3.公钥加密、私钥解密——解密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(elGamalPrivateKey.getEncoded());
            keyFactory = KeyFactory.getInstance("ElGamal");
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher = Cipher.getInstance("ElGamal");
            cipher.init(Cipher.DECRYPT_MODE,privateKey);
            result = cipher.doFinal(result);
            System.out.println("公钥加密、私钥解密——解密：" + new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


}
 
 
 
RSA——基于因子分解
 
 
Elgamal——基于离散对数
 
 
 
 
大家可以动手试一下，其实挺好理解的，大部分实现都是一样，学会一种，就可以举一反三了。
 
 
不足之处，可以关注私信沟通，期待技术交流！
 
 
作者：筱白爱学习！！
 
欢迎关注转发评论点赞沟通，您的支持是筱白的动力！
 
 

安全架构-加密算法-对称加密
 
本系列安全架构文章中，之前谈到了api接口签名防止数据篡改，但是关键数据在通讯过程中是不能明文传递的，这就涉及到另外的安全问题，数据加密传输。
 
 
加密算法根据加密秘钥的不同分为对称加密和非对称加密。加密和解密使用同一个秘钥时，称之为 对称加密。加密和解密使用不同的秘钥时，称之为非对称加密，如使用密钥对里的公钥加密，私钥解密。本文介绍对称加密算法，后续文章再来介绍非对称加密。
 


 
文章目录
 
安全架构-加密算法-对称加密
前言
一、简介
二、特点
三、常见算法
四、加密填充模式
五、加密算法的选择
六、加密算法的实现
总结

 
 
前言
 
对称加密算法是应用较早的加密算法，技术成熟。在对称加密算法中，数据发信方将明文（原始数据）和加密密钥（mi yao）一起经过特殊加密算法处理后，使其变成复杂的加密密文发送出去。收信方收到密文后，若想解读原文，则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密，才能使其恢复成可读明文。在对称加密算法中，使用的密钥只有一个，发收信双方都使用这个密钥对数据进行加密和解密，这就要求解密方事先必须知道加密密钥。
 
 
一、简介
 
指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性。
 
二、特点
 
对称加密算法的特点是算法公开、计算量小、加密速度快、加密效率高。
 假设两个用户需要使用对称加密方法加密然后交换数据，则用户最少需要2个密钥并交换使用，如果企业内用户有n个，则整个企业共需要n×(n-1) 个密钥，密钥的生成和分发将成为企业信息部门的恶梦。
 
对称加密算法的安全性取决于加密密钥的保存情况，但要求企业中每一个持有密钥的人都保守秘密是不可能的，他们通常会有意无意的把密钥泄漏出去——如果一个用户使用的密钥被入侵者所获得，入侵者便可以读取该用户密钥加密的所有文档，如果整个企业共用一个加密密钥，那整个企业文档的保密性便无从谈起。
 
三、常见算法
 
常见的对称加密算法：DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES；
 3DES其实是做三次DES。
 
最常用的：
 
 
 
DES（Data Encryption Standard）：数据加密标准，速度较快，适用于加密大量数据的场合；
 
 
3DES（Triple DES）：是基于DES，对一块数据用三个不同的密钥进行三次加密，强度更高；
 
 
AES（Advanced Encryption Standard）：高级加密标准，是下一代的加密算法标准，速度快，安全级别高。
 
 
四、加密填充模式
 
加密模式(英文名称及简写) 中文名称
 Electronic Code Book(ECB) 电子密码本模式
 Cipher Block Chaining(CBC) 密码分组链接模式
 Cipher Feedback Mode(CFB） 加密反馈模式
 Output Feedback Mode(OFB) 输出反馈模式
 
 
 
ECB：最基本的加密模式，也就是通常理解的加密，相同的明文将永远加密成相同的密文，无初始向量，容易受到密码本重放攻击，一般情况下很少用。
 
 
 
 
CBC：明文被加密前要与前面的密文进行异或运算后再加密，因此只要选择不同的初始向量，相同的密文加密后会形成不同的密文，这是目前应用最广泛的模式。CBC加密后的密文是上下文相关的，但明文的错误不会传递到后续分组，但如果一个分组丢失，后面的分组将全部作废(同步错误)。
 
 
 
 
CFB：类似于自同步序列密码，分组加密后，按8位分组将密文和明文进行移位异或后得到输出同时反馈回移位寄存器，优点最小可以按字节进行加解密，也可以是n位的，CFB也是上下文相关的，CFB模式下，明文的一个错误会影响后面的密文(错误扩散)。
 
 
 
 
OFB：将分组密码作为同步序列密码运行，和CFB相似，不过OFB用的是前一个n位密文输出分组反馈回移位寄存器，OFB没有错误扩散问题。
 
 
五、加密算法的选择
 
由于非对称加密算法的运行速度比对称加密算法的速度慢很多，当我们需要加密大量的数据时，建议采用对称加密算法，提高加解密速度。
 
对称加密算法不能实现签名，因此签名只能非对称算法。
 
由于对称加密算法的密钥管理是一个复杂的过程，密钥的管理直接决定着他的安全性，因此当数据量很小时，我们可以考虑采用非对称加密算法。
 
在实际的操作过程中，我们通常采用的方式是：采用非对称加密算法管理对称算法的密钥，然后用对称加密算法加密数据，这样我们就集成了两类加密算法的优点，既实现了加密速度快的优点，又实现了安全方便管理密钥的优点。
 
那采用多少位的密钥呢？ RSA建议采用1024位的数字，ECC建议采用160位，AES采用128为即可。
 
六、加密算法的实现
 
各技术栈都有相对应算法的完善的类库
 
.NET
 
 /// <summary>
        /// DES加密
        /// </summary>
        /// <param name="source">要加密的源字符串</param>
        /// <param name="key">公钥</param>
        /// <returns></returns>
        public static string Encrypt(string source, string key)
        {
            DESCryptoServiceProvider provider = new DESCryptoServiceProvider();
            provider.Key = Encoding.ASCII.GetBytes(key);
            provider.IV = Encoding.ASCII.GetBytes(key);
            byte[] bytes = Encoding.GetEncoding("GB2312").GetBytes(source);
            MemoryStream stream = new MemoryStream();
            CryptoStream stream2 = new CryptoStream(stream, provider.CreateEncryptor(), CryptoStreamMode.Write);
            stream2.Write(bytes, 0, bytes.Length); stream2.FlushFinalBlock();
            StringBuilder builder = new StringBuilder(); foreach (byte num in stream.ToArray())
            {
                builder.AppendFormat("{0:X2}", num);
            }
            stream.Close();
            return builder.ToString().ToByteArray().ToHexString();
        }

 
DESCryptoServiceProvider provider = new DESCryptoServiceProvider();
 可指定对应的padding和mode.
 
      provider.Padding = PaddingMode.None;
      provider.Mode = CipherMode.CBC;
 
JAVA实现
 
/**
     * 偏移变量，固定占8位字节
     */
    private final static String IV_PARAMETER = "12345678";
    /**
     * 密钥算法
     */
    private static final String ALGORITHM = "DES";
    /**
     * 加密/解密算法-工作模式-填充模式
     */
    private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
    /**
     * 默认编码
     */
    private static final String CHARSET = "utf-8";
 
    /**
     * 生成key
     *
     * @param password
     * @return
     * @throws Exception
     */
    private static Key generateKey(String password) throws Exception {
        DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
        return keyFactory.generateSecret(dks);
    }
 
 
    /**
     * DES加密字符串
     *
     * @param password 加密密码，长度不能够小于8位
     * @param data 待加密字符串
     * @return 加密后内容
     */
    public static String encrypt(String password, String data) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null)
            return null;
        try {
            Key secretKey = generateKey(password);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
            byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
 
            //JDK1.8及以上可直接使用Base64，JDK1.7及以下可以使用BASE64Encoder
            //Android平台可以使用android.util.Base64
            return new String(Base64.getEncoder().encode(bytes));
 
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }
 
    /**
     * DES解密字符串
     *
     * @param password 解密密码，长度不能够小于8位
     * @param data 待解密字符串
     * @return 解密后内容
     */
    public static String decrypt(String password, String data) {
        if (password== null || password.length() < 8) {
            throw new RuntimeException("加密失败，key不能小于8位");
        }
        if (data == null)
            return null;
        try {
            Key secretKey = generateKey(password);
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
            return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
        } catch (Exception e) {
            e.printStackTrace();
            return data;
        }
    }
 

 
总结
 
本篇简要介绍加密算法中的对称加密，对称加密中的DES,3DES,AES用的比较广泛，可以在后续文章中深度解读。
 
参考资料：
 https://my.oschina.net/u/4277503/blog/4647838