DES算法和RSA算法的区别

Posted 2023-04-15

详细点，拜托了

DES算法全称为Data Encryption Standard,即数据加密算法,它是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密。 DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位，其算法主要分为两步： 1初始置换 其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长3 2位,其置换规则为将输入的第58位换到第一位,第50位换到第2位……依此类推,最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位,R0是右32位,例:设置换前的输入值为D1D2D3……D64,则经过初始置换后的结果为:L0=D58D50……D8;R0=D57D49……D7。 2逆置换 经过16次迭代运算后,得到L16、R16,将此作为输入,进行逆置换,逆置换正好是初始置换的逆运算，由此即得到密文输出。 RSA算法简介 这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。但RSA的安全性一直未能得到理论上的证明。 RSA的安全性依赖于大数分解。公钥和私钥都是两个大素数（ 大于 100个十进制位）的函数。据猜测，从一个密钥和密文推断出明文的难度等同于分解两个大素数的积。 密钥对的产生。选择两个大素数，p 和q 。计算： n = p * q 然后随机选择加密密钥e，要求 e 和 ( p - 1 ) * ( q - 1 ) 互质。最后，利用Euclid 算法计算解密密钥d, 满足 e * d = 1 ( mod ( p - 1 ) * ( q - 1 ) ) 其中n和d也要互质。数e和n是公钥，d是私钥。两个素数p和q不再需要，应该丢弃，不要让任何人知道。 加密信息 m（二进制表示）时，首先把m分成等长数据块 m1 ,m2,..., mi ，块长s，其中 2^s <= n, s 尽可能的大。对应的密文是： ci = mi^e ( mod n ) ( a ) 解密时作如下计算： mi = ci^d ( mod n ) ( b ) RSA 可用于数字签名，方案是用 ( a ) 式签名， ( b )式验证。具体操作时考虑到安全性和 m信息量较大等因素，一般是先作 HASH 运算。 RSA 的安全性。 RSA的安全性依赖于大数分解，但是否等同于大数分解一直未能得到理论上的证明，因为没有证明破解RSA就一定需要作大数分解。假设存在一种无须分解大数的算法，那它肯定可以修改成为大数分解算法。目前， RSA的一些变种算法已被证明等价于大数分解。不管怎样，分解n是最显然的攻击方法。现在，人们已能分解140多个十进制位的大素数。因此，模数n必须选大一些，因具体适用情况而定。 RSA的速度。 由于进行的都是大数计算，使得RSA最快的情况也比DES慢上100倍，无论是软件还是硬件实现。速度一直是RSA的缺陷。一般来说只用于少量数据加密。 RSA的选择密文攻击。 RSA在选择密文攻击面前很脆弱。一般攻击者是将某一信息作一下伪装(Blind)，让拥有私钥的实体签署。然后，经过计算就可得到它所想要的信息。实际上，攻击利用的都是同一个弱点，即存在这样一个事实：乘幂保留了输入的乘法结构： ( XM )^d = X^d *M^d mod n 前面已经提到，这个固有的问题来自于公钥密码系统的最有用的特征--每个人都能使用公钥。但从算法上无法解决这一问题，主要措施有两条：一条是采用好的公钥协议，保证工作过程中实体不对其他实体任意产生的信息解密，不对自己一无所知的信息签名；另一条是决不对陌生人送来的随机文档签名，签名时首先使用One-Way Hash Function对文档作HASH处理，或同时使用不同的签名算法。在中提到了几种不同类型的攻击方法。 RSA的公共模数攻击。 若系统中共有一个模数，只是不同的人拥有不同的e和d，系统将是危险的。最普遍的情况是同一信息用不同的公钥加密，这些公钥共模而且互质，那末该信息无需私钥就可得到恢复。设P为信息明文，两个加密密钥为e1和e2，公共模数是n，则： C1 = P^e1 mod n C2 = P^e2 mod n 密码分析者知道n、e1、e2、C1和C2，就能得到P。 因为e1和e2互质，故用Euclidean算法能找到r和s，满足： r * e1 + s * e2 = 1 假设r为负数，需再用Euclidean算法计算C1^(-1)，则 ( C1^(-1) )^(-r) * C2^s = P mod n 另外，还有其它几种利用公共模数攻击的方法。总之，如果知道给定模数的一对e和d，一是有利于攻击者分解模数，一是有利于攻击者计算出其它成对的e’和d’，而无需分解模数。解决办法只有一个，那就是不要共享模数n。 RSA的小指数攻击。 有一种提高RSA速度的建议是使公钥e取较小的值，这样会使加密变得易于实现，速度有所提高。但这样作是不安全的，对付办法就是e和d都取较大的值。 RSA算法是第一个能同时用于加密和数字签名的算法，也易于理解和操作。 RSA是被研究得最广泛的公钥算法，从提出到现在已近二十年，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。RSA的安全性依赖于大数的因子分解，但并没有从理论上证明破译RSA的难度与大数分解难度等价。即RSA的重大缺陷是无法从理论上把握它的保密性能如何，而且密码学界多数人士倾向于因子分解不是NPC问题。RSA的缺点主要有：A)产生密钥很麻烦，受到素数产生技术的限制，因而难以做到一次一密。B)分组长度太大，为保证安全性，n 至少也要 600 bits以上，使运算代价很高，尤其是速度较慢，较对称密码算法慢几个数量级；且随着大数分解技术的发展，这个长度还在增加，不利于数据格式的标准化。目前，SET(Secure Electronic Transaction)协议中要求CA采用2048比特长的密钥，其他实体使用1024比特的密钥。参考资料： http://www.radyinfo.com/KNOWLEDGE/RSA.HTM 参考技术A RAS:不对称加密算法

不对称加密算法使用两把完全不同但又是完全匹配的一对钥匙—公钥和私钥。在使用不对称加密算法加密文件时，只有使用匹配的一对公钥和私钥，才能完成对明文的加密和解密过程。加密明文时采用公钥加密，解密密文时使用私钥才能完成，而且发信方（加密者）知道收信方的公钥，只有收信方（解密者）才是唯一知道自己私钥的人。不对称加密算法的基本原理是，如果发信方想发送只有收信方才能解读的加密信息，发信方必须首先知道收信方的公钥，然后利用收信方的公钥来加密原文；收信方收到加密密文后，使用自己的私钥才能解密密文。显然，采用不对称加密算法，收发信双方在通信之前，收信方必须将自己早已随机生成的公钥送给发信方，而自己保留私钥。由于不对称算法拥有两个密钥，因而特别适用于分布式系统中的数据加密。广泛应用的不对称加密算法有RSA算法和美国国家标准局提出的DSA。以不对称加密算法为基础的加密技术应用非常广泛。
DES算法

DES算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的对称密码体制加密算法。

其密钥长度为56位，明文按64位进行分组，将分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

DES加密算法特点：分组比较短、密钥太短、密码生命周期短、运算速度较慢。

DES工作的基本原理是，其入口参数有三个:key、data、mode。 key为加密解密使用的密钥，data为加密解密的数据，mode为其工作模式。当模式为加密模式时，明文按照64位进行分组，形成明文组，key用于对数据加密，当模式为解密模式时，key用于对数据解密。实际运用中，密钥只用到了64位中的56位，这样才具有高的安全性。 参考技术B 这方面的详细资料还是要看书，或在网上搜，是密码基础知识。

我只想说明三点，一是这两种算法用途不一样，没有可比性。二是该两种算法的强度已公认的不够，比如DES算法在网上有现成的破解程序，在重要项目开发中使用这些算法将很难通过签定。三是这些教科书式的算法仅管公开透明，但保密性得不到保证。比如美国人搞的DES算法，很多环节都知其然不知其所以然，有没有后门在数学上还很难证明。 参考技术C 利用算法核心代码封装的接口函数笔者编写了一个针对文本文件的加密解密工具.下文叙述了在实践时的一些心得体会,希望能对读者有所裨益.
笔者选择把密文以16进制的形式写入文件的方法.当然也可以直接写入文件.
例:
密文为:12345678
在内存中显示为:
31 32 33 34 35 36 37 38
那么就把以3132333435363738的形式写入文件.
为了解密的方便,密文中的每个字节用两个字节表示,也即在内存中显示为0x9A的内容,就以9A的形式写入文件中.当内存中显示的内容为0x0?(?代表0~F)形式时,需要以0?的形式写入文件.
这样可以避开前面提及的问题,只是在解密时先按照两两组合的原则,顺序把从文件中读取的数据转换成待解的密文.
例:
读出的数据是:
3132333435363738
那么复原的过程:
31->1
32->2
33->3
….
38->8
最终得真正的密文12345678,这样就可以调用DES算法解密函数从密文得到明文.
DES算法是对固定大小(64位)的数据块进行加密解密操作的,对于那些不够64位的数据块需要采用填充机制补位到64位长,为了方便使用,数据位的填充是对用户而言是透明的,利用该工具进行加密解密操作时,用户只需输入操作的类型、读取数据的文件名、写入操作结果的文件名、密钥等信息.
操作思路:
#define READFILESIZE 512
步骤:
1.从文件中读取READFILESIZE个字节的数据
2.,如果从文件中读出的数据少于READFILESIZE个,以0补足,然后根据用户指定的类型对这READFILESIZE个字节的数据进行操作.
3.判断文件是否结束,没有则执行步骤1
4.把加密后的文件实际长度添加到密文的末尾
5.结束
采用一次只从文件读取READFILESIZE个字节是在为了防止由于需要加密或解密的文件太大导致内存不够的情况出现.

3.2 注意事项

DES算法的加密密钥是根据用户输入的密码生成的,该算法把64位密码中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作为奇偶校验位,在计算密钥时要忽略这8位.如果输入的密码只是在这8位上有区别的话,那么操作后的结果将是一样的.
例:
输入的密码为wuzhenll,密钥的16进制表示为77 75 7A 68 65 6E 6C 6C
任意改变这64位数据的奇偶校验位,可以得到16个不同的密码,
把8个奇偶检验位全取反后:
w->v
u->t
z->
h->i
e->d
n->o
l->m
形成新密码:vtidomm
表面上新密码和原密码迥然不同,但是由于他们仅在奇偶校验位上有区别,所以用这两个密码进行加密解密操作得到的结果是一样的.
笔者建议使用安全系数较高的多密钥加密解密方案.
此外用户输入的密码的长度不受限制,当输入的密码长度为0时,使用缺省64位密码;当输入的密码长度大于8字节时,输入密码的前8个字节为有效密码.
该工具提供6种不同的操作类型:

1:一层加密;
2:一层解密;

3:N层单密钥加密;
4:N层单密钥解密;

5:N层多密钥加密;
6:N层多密钥解密;

这六种操作是对称使用的,例如:加密明文时选择一层加密,解密时对密文使用一层解密

DES和RSA混合加密&解密

        关于DES和RSA各自单独加密的弊端大家自行学习吧，本文使用对称式加密算法DES和非对称式加密算法RSA结合做数据加密的方式，先进行DES加密，将DES加密后的内容进行base64编码，再将base64编码的DES进行RSA加密，本文分别创建DES和RSA工具类，便于单独使用，也可混合使用。具体步骤如下：

1、POM文件添加相关jar包

        <!-- DES -->
        <dependency>
            <groupId>javax.xml.rpc</groupId>
            <artifactId>javax.xml.rpc-api</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!-- RSA -->
        <dependency>
            <groupId>org.apache.axis</groupId>
            <artifactId>axis</artifactId>
            <version>1.4</version>
        </dependency>
        <!-- base64 -->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.10</version>
        </dependency>

2、自定义一个DES密钥，最好是8位，放在配置文件里面

3、生成一对RSA公钥和私钥，也放在配置文件里面

生成代码：

 /**
     * 生成RSA密钥对
     */
    protected static Map<String, String> genKeyPairMap() 
        Map<String, String> keyPairMap = new HashMap<>(2);
        // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
        KeyPairGenerator keyPairGen = null;
        try 
            keyPairGen = KeyPairGenerator.getInstance("RSA");
            // 初始化密钥对生成器，密钥大小为96-1024位
            keyPairGen.initialize(1024, new SecureRandom());
            // 生成一个密钥对，保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            // 得到私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // 得到公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            // 得到公钥字符串
            String publicKeyString = getKeyString(publicKey);
            // 得到私钥字符串
            String privateKeyString = getKeyString(privateKey);
            keyPairMap.put("publicKey", publicKeyString);
            keyPairMap.put("privateKey", privateKeyString);
         catch (Exception e) 
            logger.error("[RsaUtil]-生成密钥对失败！ ---------------", e);
            throw new PlatException("[RsaUtil]-生成密钥对失败！");
        
        return keyPairMap;
    

配置文件

desKey = dev-2022
RSA_public_key = MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDylxBFYYsoc9sfyWJ9sdWlsJj13aOcqDhaX5FLAyZP4mz7Jz4cGzDQkY1iGBKHl5NC24dD0f7y1KUncE/8qAgoPiX1T5uK6CC5d/AxLK+ElrhiTp+mtkuGZKAQ9oO+bzqNMH0yP80LXVGXQlIOPjP5/lduG+X1JwsOLyCpPvhCTQIDAQAB
RSA_private_key = MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAPKXEEVhiyhz2x/JYn2x1aWwmPXdo5yoOFpfkUsDJk/ibPsnPhwbMNCRjWIYEoeXk0Lbh0PR/vLUpSdwT/yoCCg+JfVPm4roILl38DEsr4SWuGJOn6a2S4ZkoBD2g75vOo0wfTI/zQtdUZdCUg4+M/n+V24b5fUnCw4vIKk++EJNAgMBAAECgYEAhfEEidpOtFornYRavh3nYaF9AxuKD6AN5VAo76rgh3D0TUOglnIo5K/IyWWTLYxyQZLmP3r98mOYgIsRjuXUAhkCUqSvMrNZ+jSSpCo3ceey+Cd3JJQigv24oRvYvA7rgmmUOQ1FojyVva43Bm5w6Om8oh0LMSKH7h4xv/XjgSECQQD7iHNQieUWJ9J4feRCwqILSnpXiAtQOk9oq46R8FoSOO7NVmbsNGEoS2aYH3gDeMaMPIZGyQtP/DMZOeOB6CjJAkEA9uX0q8dqq96zWSX8ptTEKFWI3P+YUbg4dg+dKt46vrY037DnNGRO3tjEruPnZuAUQ0CQyXc6foYqvUUVum9TZQJAbNXEt5OC+UwvyI0IaE6ZGPOX7iniY0tnsq2Qmdr6zimuQlDhZdDgPTQq5yWuoynuFx3VJ+mzqF9CqOagZ0RR6QJBAJxKaR2seLwfl4yhXVQGb73Ql3i+W5+vbB5gN++BCdLb6JCJnXIu5TZwJeFH553ZzznbT0wZK3AYYkm5x81i13kCQFyJP2FzPiyEFhisPWQi0bXZQQlwMCimZJknl75OAZCDgDNouBH2jSu7g7zBPRU15X9fmMNdeF3Wl3srUNkRHoI=

4、创建DES加解密工具类

import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

/**
 * @author qigc
 * @Description ES和RSA混合加密，先进行DES加密，将DES加密后的内容进行base64编码，再将base64编码的DES进行RSA加密
 * @createTime 2021年08月23日 15:42:00
 */
public class DEUtil 

    private static final Logger logger = LoggerFactory.getLogger(DEUtil.class);
    /**
     * 编码格式
     */

    private static final String DES_KEY = "desKey";
    private static final String PUBLIC_KEY = "RSA_public_key";
    private static final String PRIVATE_KEY = "RSA_private_key";

    /**
     * 加密
     *
     * @param content 加密内容
     * @return
     */
    public static String encrypt(String content) 
        String rsaContent = null;
        try 
            //从配置文件获取des密钥8位
            String desKey = PlatApplicationContext.getProperties(DES_KEY);
            //DES加密
            String desContent  = DesUtil.encrypt(content, desKey);
            //从配置文件获取公钥key
            String pubKey = PlatApplicationContext.getProperties(PUBLIC_KEY);
            //根据公钥key获取公钥
            RSAPublicKey publicKey = RsaUtil.getPublicKey(pubKey);
            //RSA加密
            rsaContent = RsaUtil.publicEncrypt(desContent, publicKey);
         catch (Exception e) 
            logger.error("[DEUtil]-加密失败！ ---------------", e);
            throw new PlatException("[DEUtil]-加密失败！");
        
        return rsaContent;
    

    /**
     * @return java.lang.String
     * @author qigc
     * 解密
     * @date 2021/8/23
     */
    public static String decode(String rsaContent) 
        String content = null;
        try 
            //从配置文件获取des密钥8位
            String desKey = PlatApplicationContext.getProperties(DES_KEY);
            String priKey = PlatApplicationContext.getProperties(PRIVATE_KEY);
            //获取私钥
            RSAPrivateKey privateKey = RsaUtil.getPrivateKey(priKey);
            //RSA解密
            String contentRsa = RsaUtil.privateDecryptToString(rsaContent,privateKey);
            //DES解密
            content = DesUtil.decrypt(contentRsa,desKey);
         catch (Exception e) 
            logger.error("[DEUtil]-解密失败！ ---------------", e);
            throw new PlatException("[DEUtil]-解密失败！");
        
        return content;
    

5、创建RSA加密解密工具类RsaUtil

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

import javax.crypto.Cipher;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.FileWriter;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * @author qigc
 * @Description RSA工具类
 * @createTime 2021年08月23日 15:14:00
 */
class RsaUtil 

    private static final Logger logger = LoggerFactory.getLogger(RsaUtil.class);
    /**
     * 编码格式
     */
    private static final String E_CODE_TYPE = "UTF-8";

    /**
     * 转密钥字符串（base64编码）
     *
     * @return
     */
    private static String getKeyString(Key key) throws Exception 
        byte[] keyBytes = key.getEncoded();
        return new String(Base64.encodeBase64(keyBytes));
    

    /**
     * 得到公钥
     *
     * @param publicKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    protected static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException 
        //通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
        return (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
    

    /**
     * 得到私钥
     *
     * @param privateKey 密钥字符串（经过base64编码）
     * @throws Exception
     */
    protected static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException 
        //通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
        return (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
    

   

    /**
     * 公钥加密
     *
     * @param data      需要加密的内容
     * @param publicKey 公钥
     * @return
     */
    protected static String publicEncrypt(String data, RSAPublicKey publicKey) 
        try 
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return new String(Base64.encodeBase64(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(E_CODE_TYPE), publicKey.getModulus().bitLength())));
         catch (Exception e) 
            logger.error("[RsaUtil]-公钥加密失败！ ---------------", e);
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        
    

    /**
     * 私钥解密
     *
     * @param data       需要加密的内容
     * @param privateKey 私钥
     * @return
     */

    protected static String privateDecryptToString(String data, RSAPrivateKey privateKey) 
        try 
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), E_CODE_TYPE);
         catch (Exception e) 
            logger.error("[RsaUtil]-私钥解密失败！ ---------------", e);
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        
    

    /**
     * 私钥解密
     *
     * @param data       需要加密的内容
     * @param privateKey 私钥
     * @return
     */

    protected static byte[] privateDecrypt(String data, RSAPrivateKey privateKey) 
        try 
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength());
         catch (Exception e) 
            logger.error("[RsaUtil]-私钥解密失败！ ---------------", e);
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        
    

    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) 
        int maxBlock = 0;
        if (opmode == Cipher.DECRYPT_MODE) 
            maxBlock = keySize / 8;
         else 
            maxBlock = keySize / 8 - 11;
        
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] buff;
        int i = 0;
        try 
            while (datas.length > offSet) 
                if (datas.length - offSet > maxBlock) 
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                 else 
                    buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            
         catch (Exception e) 
            logger.error("[RsaUtil]-加解密失败！ ---------------", e);
            throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
        
        byte[] resultDatas = out.toByteArray();
        IOUtils.closeQuietly(out);
        return resultDatas;
    

6、创建DES+RSA混合加解密工具类DEUtil

import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;

/**
 * @author qigc
 * @Description ES和RSA混合加密，先进行DES加密，将DES加密后的内容进行base64编码，再将base64编码的DES进行RSA加密
 * @createTime 2021年08月23日 15:42:00
 */
public class DEUtil 

    private static final Logger logger = LoggerFactory.getLogger(DEUtil.class);
    /**
     * 编码格式
     */

    private static final String DES_KEY = "desKey";
    private static final String PUBLIC_KEY = "RSA_public_key";
    private static final String PRIVATE_KEY = "RSA_private_key";

    /**
     * 加密
     *
     * @param content 加密内容
     * @return
     */
    public static String encrypt(String content) 
        String rsaContent = null;
        try 
            //从配置文件获取des密钥8位
            String desKey = PlatApplicationContext.getProperties(DES_KEY);
            //DES加密
            String desContent  = DesUtil.encrypt(content, desKey);
            //从配置文件获取公钥key
            String pubKey = PlatApplicationContext.getProperties(PUBLIC_KEY);
            //根据公钥key获取公钥
            RSAPublicKey publicKey = RsaUtil.getPublicKey(pubKey);
            //RSA加密
            rsaContent = RsaUtil.publicEncrypt(desContent, publicKey);
         catch (Exception e) 
            logger.error("[DEUtil]-加密失败！ ---------------", e);
            throw new PlatException("[DEUtil]-加密失败！");
        
        return rsaContent;
    

    /**
     * @return java.lang.String
     * @author qigc
     * 解密
     * @date 2021/8/23
     */
    public static String decode(String rsaContent) 
        String content = null;
        try 
            //从配置文件获取des密钥8位
            String desKey = PlatApplicationContext.getProperties(DES_KEY);
            String priKey = PlatApplicationContext.getProperties(PRIVATE_KEY);
            //获取私钥
            RSAPrivateKey privateKey = RsaUtil.getPrivateKey(priKey);
            //RSA解密
            String contentRsa = RsaUtil.privateDecryptToString(rsaContent,privateKey);
            //DES解密
            content = DesUtil.decrypt(contentRsa,desKey);
         catch (Exception e) 
            logger.error("[DEUtil]-解密失败！ ---------------", e);
            throw new PlatException("[DEUtil]-解密失败！");
        
        return content;