精华内容
下载资源
问答
  • 混合加密
    千次阅读
    2022-02-06 18:13:00

    1.对称加密

    AES,密钥长度有128/256/192。高级加密标准,是下一代的加密算法标准,速度快,安全级别高;
    DES:密钥为56, 数据加密标准,速度较快,适用于加密大量数据的场合。
    3DES: 密钥为168.是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高。
    IDES: 密钥为128
    SM1: 密钥为128
    SM4: 密钥为128
    RC4, RC5, RC6
    DESX

    两边用同一个密钥来加解密。

    1.1 对称加密的有优缺点

    • 加解密速度快
    • 会出现密钥分配问题;密钥容易复制,不便于安全保管

    1.2 密钥分配问题

    对称加密的存在密钥分配问题,A的密钥怎么才能安全的传输到B手里不被X获取到?A直接发送密钥给B还是可能被X窃取到这个密钥.

    只有用密钥加密后的信息才能安全传输,但是只有保证安全传输的前提下才能发送这个密钥。

    2.非对称加密

    RSA,: 由 RSA 公司发明,是一个支持变长密钥的公共密钥算法,需要加密的文件块的长度也是可变的;
    SM2,
    ECC: 椭圆曲线密码编码学。移动设备用。
    DSA:数字签名算法,是一种标准的 DSS(数字签名标准)

    双方使用不同的密钥来加解密,并且不能通过一个密钥推算出另一个密钥

    • 公钥加密,私钥解密
    • 私钥加密(数字签名),公钥解密

    A把事先准备好了非对称密钥对,分别为公钥和私钥,这一套非对称密钥对能相互加解密。公钥是公开的,私钥只有自己才有。然后A把公钥发送给B,或者公钥放在服务器B自行下载。B拿到了公钥后用公钥的一套算法加密信息后传输给A,A用私钥执行另一个算法解密获得明文信息。

    2.1 非对称加密的优缺点

    • 不会出现密钥分配问题
    • 加解密速度慢,仍有被窃听的隐患

    3.混合加密

    传输大量数据的时候使用对称加密,因为加解密速度快。但是由于对称加密有秘钥分配问题,所以我们用非对称加密来加密这个对称密钥再传递给对方。

    • A:这是我的公钥public_A,你收好,你生成对称密钥也给我一下
    • B:好的,收到public_A,你收好对称密钥secretKey。然后用public_A加密这个secretKey
    • A:收到消息,private_A解密出来是secretKey。

    中间人攻击:
    在这里插入图片描述

    • A:这是我的公钥public_A,你收好,你生成对称密钥也给我一下
    • X获得了A的公钥,把自己的公钥public_X发给B… B这傻子还以为真的是A的公钥呢
    • B:好的,公钥public_X已收到,生成一个对称密钥secretKey,然后用public_X加密这个对称密钥。
    • X截获了这个消息,用自己私钥private_X解密出对称密钥secretKey,自己再生成一个secretKeyXXX用public_A加密一下发送给A。A这傻子还以为你们接下来会安全的用secretKey通信吗哈哈哈
    • A:收到消息,private_A解密出来对称密钥secretKeyXXX(其实是X篡改了)
      在这里插入图片描述上图中,中间人X能不仅获取A和B之间通信内容,还能任意修改,相当于一个代理抓包,修改数据。

    4.常见的摘要算法

    单向散列函数一般用于产生消息摘要,密钥加密等,常见的Hash算法:
    MD5, SHA1, SHA2 (SHA224, SHA256, SHA384),HMAC,HMAC-MD5,HMAC-SHA1
    MD5,SHA1不具有很强的碰撞性,用的比较多的是SHA2

    摘要算法:

    在这里插入图片描述
    1.不可逆性
    2.难题友好性:想要破解,只可以暴力破解
    3.发散性:只要对原文有一点修改,摘要会有巨大的改变
    4.碰撞性:原文不同,计算后的摘要也不同

    更多相关内容
  • 基于AES的加密算法具有速度快、强度高、便于实现等优点和ECC加密算法具有密钥分配与管理简单、安全强度高等优点,采用AES加密算法加密大数据块,而用ECC加密算法管理AES密钥,通过集成AES加密算法和ECC加密算法的...
  • RSA、DES混合加密解决方案、数字签名,该文件包含远吗和可直接使用的jar。功能包扩 0、程序自动生成公私钥。 1、客户端 公钥加密 2、服务端 私钥解密数据获取内容3、服务端私钥加密数据4、客户端公钥解密 5、私钥...
  • RSA和AES混合加密demo

    2017-11-29 18:20:10
    RSA和AES混合加密demo
  • 分析了对称加密算法AES和非对称加密算法ECC的加密过程和特点,并结合两种算法的特点设计了一种混合加密体制,在避免了对称加密算法复杂的密钥分配体制的同时保证了加密的效率和强度。同时引入了改进的数字签名算法...
  • VC 混合加密算法应用实例,代码由东北大学信息科学与工程学院安全与保密小组编写,系统实现了一个基本的混合密码系统。它使用DES作为对称密钥算法,RSA作为公开密钥算法。  VC 混合加密系统特点如下:1:提供了俩...
  • 密钥分配(RSA+DES混合加密含源程序) - lly1122334的博客 - CSDN博客 http://blog.csdn.net/lly1122334/article/details/78959639
  • 在此基础上,结合两种算法的优点,并采用消息摘要、数字签名、数字信封等技术构建了一个既方便密钥管理又确保加密解密效率的混合加密体制。实验结果表明优化后的算法在运算速度上有一定优势并且有较高的可行性。
  • 基于YUV的混合加密算法的研究
  • JavaMd5混合加密

    2018-04-16 17:33:39
    使用java编写的加密工具类,使用时加入到自己的工程中,并把j里面ar包添加到类库中,即可调用,采用了多重加密技术
  • 混合加密

    千次阅读 2018-12-24 10:50:18
    前言 上一篇文章我们提到了公开密钥加密方法 并且剖析了它的优点和缺点,优点主要是加密解密比较安全,在攻击人没有拿到私钥的情况下,使用此种加密解密方式几乎不可能被破解;...混合加密 当我们使用对称加...

    前言

    上一篇文章我们提到了非对称密钥加密方法

    并且剖析了它的优点和缺点,优点主要是加密解密比较安全,在攻击人没有拿到私钥的情况下,使用此种加密解密方式几乎不可能被破解;缺点有两个,第一个是使用此种方式的性能比较不好,第二个是在公钥的交付过程中可能会被攻击人拦截到并且替换成自己的公钥,让甲方和乙方在自以为很安全的情况下就泄露了自己的信息。此篇博文我们先来解决一下第一个问题。

    混合加密

    当我们使用对称加密解密的时候,存在对称加密钥匙被劫持的问题,但是速度较快;当我们使用非对称加密解密的时候,存在速度较慢的问题,但是比较安全。那么,如果将两种方式结合一下呢?

    那就是我们的混合加密方式了,下面是混合加密的流程:

    A方想通过互联网向B方发送数据:
    在这里插入图片描述
    A方需要对数据进行加密,因为使用的是对称加密,所以加密密钥也是解密密钥,A方需要将这把钥匙发送给B方:
    在这里插入图片描述

    使用混合加密的目的是把对称加密的钥匙通过非对称加密的方式发送给B方,防止对称加密的钥匙半路被拦截,因此,B方先要创建自己的公钥和私钥:
    在这里插入图片描述

    然后B方把自己的公钥发送给A方:
    在这里插入图片描述

    A方使用B方的公钥对自己的对称钥匙进行加密:
    在这里插入图片描述
    发送给B方之后,B方再用自己的私钥对A的对称加密钥匙进行解密:
    在这里插入图片描述
    至此,B方通过安全的途径得到了A方的对称加密的钥匙,可以用来解密了(注意,安全只是相对之前单纯地传送对称加密钥匙而言,此处的安全相当于半裸之于全裸,因为我们还是需要数字签名来做到真正的安全,后面会做说明)
    在这里插入图片描述
    现在,A方可以使用对称加密钥匙加密数据,B方可以通过同一把钥匙解密数据了:
    在这里插入图片描述

    但是,我们还是没有解决在公钥的传输过程中被攻击人替换成假公钥的问题,因此,攻击人可以使用中间人攻击方法让A方使用假公钥加密,然后自己通过假私钥解密,再使用B的真公钥加密,然后发回给B,以此做到窃取AB之间使用的对称加密钥匙的目的。

    因此,我们还是需要数字证书

    • 参考资料:
      算法动画图解APP(侵删)
    展开全文
  • 基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)基于ECC和AES的混合加密应用系统 源代码+配置+毕业论文(1)基于ECC和AES的混合加密应用系统 源代码+...
  • rsa与aes混合加密java实现
  • 提出了一种高效的基于混合加密算法的Mix-net协议。正常情况下,当所有Mix服务器都忠实地执行协议时,其运算速度优于其他所有已知的具有公开可验证性的Mix-net。采用一种“乐观的”、基于散列运算的方法验证混洗过程...
  • 混合加密的原理描述

    2015-03-30 16:01:57
    混合加密算法结合了对称性加密和非对称性加密的优点,在通信过程中,除了能有效地保证安全性以外,还将加密算法的效率大大提高。混合加密算法采用了双重加密,即使有恶意用户在交换密钥的时候窃取了部分密钥,也不会...
  • 在理解了这些加密算法的局限性之后, 本文提出了一种旨在利用和组合两种加密算法最佳功能并提供比其中任何一种具有更好的安全性、实时性的替代算法, 即3DES-RC4混合加密算法, 是一种具有256个字节密钥空间的算法, ...
  • 文中提出一种新的授权加密方法, 即DPAPI加密算法和RSA数字签名算法的混合加密算法. 该算法利用DPAPI加密算法加密客户端申请授权的信息, 在实现加密的同时保证软件授权的正确性, 再利用RSA数字签名算法对服务器端的...
  • 文章目录对称加密对称加密的有优缺点密钥分配问题非对称加密非对称加密的优缺点混合加密 上一章节我们说到解决窃听的方法是加密,这里我们来说说加密 对称加密   两边用同一个密钥来加解密。   A把明文通过某一...

    章节系列目录:点击跳转

    上一章节我们说到解决窃听的方法是加密,这里我们来说说加密

    对称加密

      两边用同一个密钥来加解密。
      A把明文通过某一算法加密之后得到密文,然后把密文发送给BB接收到密文之后用相同的密钥执行相同的算法去解密。X没有密钥,即使窃取到密文也无法窃听。

    对称加密的有优缺点

      对称加密的优点:加解密速度快
      对称加密的缺点:会出现密钥分配问题;密钥容易复制,不便于安全保管

    密钥分配问题

      对称加密的存在密钥分配问题A的密钥怎么才能安全的传输到B手里不被X获取到?A直接发送密钥给B还是可能被X窃取到这个密钥,这样加密信息等于是在裸奔了。只有用密钥加密后的信息才能安全传输,但是只有保证安全传输的前提下才能发送这个密钥。

    这个道理和下图一样

    非对称加密

      双方使用不同的密钥来加解密,并且不能通过一个密钥推算出另一个密钥

    公钥加密,私钥解密
    私钥加密(数字签名),公钥解密

      A把事先准备好了非对称密钥对,分别为公钥和私钥,这一套非对称密钥对能相互加解密。公钥是公开的,私钥只有自己才有。然后A把公钥发送给B,或者公钥放在服务器B自行下载。B拿到了公钥后用公钥的一套算法加密信息后传输给AA用私钥执行另一个算法解密获得明文信息。

    非对称加密的优缺点

      非对称加密的优点:不会出现密钥分配问题
      非对称加密的缺点:加解密速度慢,仍有被窃听的隐患,原因和中间人攻击一样,后面会讲到。

      既然对称加密和非对称加密都有缺点,那么我们能不能用一种方法结合一下他们的优点形成一套比较好的方案呢?答案是有的,那就是混合加密

    混合加密

      传输大量数据的时候使用对称加密,因为加解密速度快。但是由于对称加密有秘钥分配问题,所以我们用非对称加密来加密这个对称密钥再传递给对方
    我们会认为接下来的方案应该是比较完美了吧?

      双向通信之前要先把公钥相互交换,比如A和B要通信
      A:这是我的公钥public_A,你收好,你生成对称密钥也给我一下
      B:好的,收到public_A,你收好对称密钥secretKey。然后用public_A加密这个secretKey
      A:收到消息,private_A解密出来是secretKey

      这就解决了对称密钥secretKey的密钥分配问题,然后双方就可以用secretKey加密消息进行通信了。

      但是这还不够,这仍然会被中间人攻击!你怎么知道把公钥发送给对方时保证公钥没被篡改掉包呢?比如上面的例子被中间人攻击之后就变成了下面的样子

    A:这是我的公钥public_A,你收好,你生成对称密钥也给我一下
    X获得了A的公钥,把自己的公钥public_X发给B… B这傻子还以为真的是A的公钥呢
    B:好的,公钥public_X已收到,生成一个对称密钥secretKey,然后用public_X加密这个对称密钥。
    X截获了这个消息,用自己私钥private_X解密出对称密钥secretKey,自己再生成一个secretKeyXXXpublic_A加密一下发送给A。 A这傻子还以为你们接下来会安全的用secretKey通信吗哈哈哈
    A:收到消息,private_A解密出来对称密钥secretKeyXXX(其实是X篡改了)

      X心想,这两个傻子真以为接下来用对称密钥加密就安全了呢,我倒要听听A和B在说什么悄悄话。

      上图中,中间人X能不仅获取AB之间通信内容,还能任意修改,相当于一个代理抓包,修改数据。

      我们平时所用的抓包工具就需要安装一个证书,也就是你自己糊弄自己的电脑,自己充当中间人去查看网络通讯的数据,方便学习使用。

      上面混合加密的例子已经涉及到数字签名,混合加密解决了对称密钥分配问题,后续讲解数字签名的中间人攻击也会提到这个例子,到时候可以返回来再看,中间人攻击其实就是数字签名存在的不足

      那么怎么才能防止中间人攻击呢?后续章节再给大家讲解数字证书,为大家来解决这个问题。


    关注、留言,我们一起学习。

    ----------------------Talk is cheap, show me the code-----------------------
    展开全文
  • RSA+AES混合加密-JavaWeb

    千次阅读 2021-05-06 11:36:11
    RSA+AES的混合加密时,AES用于给传输的数据加密,然后通过RSA给AES的秘钥加密,所以接收到数据后,就需要先解密得到AES的秘钥,然后通过AES秘钥再去解密得到数据。 下面简单说下demo中加密解密的

    一、前言

    RSA与AES加密的详细介绍这里就不写了,网上很多博客,这里就只是简单说明一下:

    • AES:属于对称加密,通过一个公共的秘钥,实现加密解密;
    • RSA:非对称加密,需要生成一个公钥、一个私钥,这两个秘钥使用时,一个用来加密时,那么就需要另一个秘钥进行解密,公钥一般提供给客户端。

    二、整体构思

    RSA+AES的混合加密时,AES用于给传输的数据加密,然后通过RSA给AES的秘钥加密,所以接收到数据后,就需要先解密得到AES的秘钥,然后通过AES秘钥再去解密得到数据。
    下面简单说下demo中加密解密的实现过程:

    1. 前后端各自生成自己的RSA公私密钥(这就必须确保双方的RSA算法要匹配,不然双方就无法正常解密)
    2. 当访问项目首页时,前端生成RSA秘钥,并存放在window对象中的localStorage
    3. 页面发起请求获取服务端的RSA公钥,服务端收到请求后生成RSA公司秘钥,并将秘钥放入session,所以每次建立会话连接时都是不一样的秘钥,然后将公钥返回给前端页面
    4. 页面接收到服务端的RSA公钥后,存入window对象,然后用服务端RSA公钥加密前端的RSA公钥发送给服务端
    5. 服务端收到前端发过来的请求后,通过自己的私钥解密数据,从而得到前端的公钥,并存入session。

    这里面提到的存储秘钥的方式只是在demo中作为演示使用,可以采用更合理、更安全的方式是实现!

    这样,前后端都拥有的对方RSA的公钥,后面在同一个会话中具体的请求数据时,每次各自都会生成新的AES秘钥(AES的算法也需要前后端能匹配上),RSA的秘钥则在响应位置去取就可以了。
    在这里插入图片描述
    在这里插入图片描述

    三、主要代码

    1、服务端

    两个加密解密工具类,里面部分有使用第三方jar(hutool-all.jar)。

    • AESUtil
    package com.lr.demo.util;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.UnsupportedEncodingException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.Arrays;
    
    public class AESUtil {
        private static final String KEY_ALGORITHM = "AES";
        private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
    
        public static String getKey(int len){
            if(len % 16 != 0){
                System.out.println("长度要为16的整数倍");
                return null;
            }
    
            char[] chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".toCharArray();
            char[] uuid = new char[len];
    
            if (len > 0) {
                for (int i = 0; i < len; i++) {
                    int x = (int) (Math.random() * (len - 0 + 1) + 0);
                    uuid[i] = chars[x % chars.length];
                }
            }
    
            return new String(uuid);
        }
    
    
        public static String byteToHexString(byte[] bytes){
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < bytes.length; i++) {
                String strHex=Integer.toHexString(bytes[i]);
                if(strHex.length() > 3){
                    sb.append(strHex.substring(6));
                } else {
                    if(strHex.length() < 2){
                        sb.append("0" + strHex);
                    } else {
                        sb.append(strHex);
                    }
                }
            }
            return  sb.toString();
        }
    
        /**
         * AES 加密操作
         *
         * @param content 待加密内容
         * @param key 加密密码
         * @return 返回Base64转码后的加密数据
         */
        public static String encrypt(String content, String key) {
            try {
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
    
                byte[] byteContent = content.getBytes("utf-8");
    
                cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器
    
                byte[] result = cipher.doFinal(byteContent);// 加密
    
                return org.apache.commons.codec.binary.Base64.encodeBase64String(result);//通过Base64转码返回
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
            return null;
        }
    
        /**
         * AES 解密操作
         *
         * @param content
         * @param key
         * @return
         */
        public static String decrypt(String content, String key) {
    
            try {
                //实例化
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
    
                //使用密钥初始化,设置为解密模式
                cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));
    
                //执行操作
                byte[] result = cipher.doFinal(org.apache.commons.codec.binary.Base64.decodeBase64(content));
    
                return new String(result, "utf-8");
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
            return null;
        }
    
        private static SecretKeySpec getSecretKey(final String key) throws UnsupportedEncodingException {
            //返回生成指定算法密钥生成器的 KeyGenerator 对象
            KeyGenerator kg = null;
    
            try {
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
    
                //AES 要求密钥长度为 128
                kg.init(128, new SecureRandom(key.getBytes()));
    
                //生成一个密钥
                SecretKey secretKey = kg.generateKey();
    
                return new SecretKeySpec(Arrays.copyOf(key.getBytes("utf-8"), 16), KEY_ALGORITHM);// 转换为AES专用密钥
            } catch (NoSuchAlgorithmException ex) {
                ex.printStackTrace();
            }
    
            return null;
        }
    
    }
    
    
    • RSAUtil
    package com.lr.demo.util;
    
    import cn.hutool.crypto.SecureUtil;
    import cn.hutool.crypto.asymmetric.KeyType;
    import cn.hutool.crypto.asymmetric.RSA;
    import org.springframework.util.Base64Utils;
    
    import java.io.UnsupportedEncodingException;
    import java.security.Key;
    import java.security.KeyPair;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.util.HashMap;
    import java.util.Map;
    
    public class RSAUtil {
    
        public static final String PB_KEY = "pb_key";
        public static final String PR_KEY = "pr_key";
    
        public static final String CLI_PB_KEY = "cli_pb_key";
    
        /**
         * 获取公私秘钥对
         * @return
         */
        public static Map<String, Key> getRSAKey(){
            KeyPair pair = SecureUtil.generateKeyPair("RSA");
            PrivateKey privateKey = pair.getPrivate();
            PublicKey publicKey = pair.getPublic();
    
            Map<String, Key> keys = new HashMap<>();
            keys.put(PR_KEY,privateKey);
            keys.put(PB_KEY,publicKey);
    
            return keys;
        }
    
        /**
         * 公钥加密
         * @param pbKey
         * @param content
         * @return
         */
        public static String encByPbKey(String pbKey,String content){
            try {
                byte[] bytes = Base64Utils.decode(pbKey.getBytes("UTF-8"));
                RSA rsa = new RSA(null,bytes);
                byte[] enc = rsa.encrypt(content.getBytes("UTF-8"), KeyType.PublicKey);
                String s = new String(Base64Utils.encode(enc));
                return s;
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 公钥加密
         * @param pbKey
         * @param content
         * @return
         */
        public static String encByPbKey(PublicKey pbKey,String content){
            try {
                RSA rsa = new RSA(null,pbKey);
                byte[] enc = rsa.encrypt(content.getBytes("UTF-8"), KeyType.PublicKey);
                String s = new String(Base64Utils.encode(enc));
                return s;
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 私钥解密
         * @param prKey
         * @param content
         * @return
         */
        public static String dencByPrKey(String prKey,String content){
            try {
                byte[] bytes = Base64Utils.decode(prKey.getBytes("UTF-8"));
                RSA rsa = new RSA(bytes,null);
                byte[] denc = rsa.decrypt(Base64Utils.decode(content.getBytes("UTF-8")), KeyType.PrivateKey);
                String s = new String(Base64Utils.encode(denc));
                return s;
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 私钥解密
         * @param prKey
         * @param content
         * @return
         */
        public static String dencByPrKey(PrivateKey prKey,String content){
            try {
                RSA rsa = new RSA(prKey,null);
                byte[] denc = rsa.decrypt(Base64Utils.decode(content.getBytes("UTF-8")), KeyType.PrivateKey);
                String s = new String(denc);
                return s;
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return null;
        }
    
    }
    
    

    l两个Controller,一个是初始化是秘钥交换的,一个用于测试

    package com.lr.demo.controller;
    
    import com.lr.demo.commons.Result;
    import com.lr.demo.util.RSAUtil;
    import org.springframework.util.Base64Utils;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpSession;
    import java.security.Key;
    import java.security.PrivateKey;
    import java.util.List;
    import java.util.Map;
    
    @RestController
    @RequestMapping("secret")
    public class SecretController {
    
        /**
         * 返回服务端的RSA公钥
         * @param session
         * @return
         */
        @RequestMapping("getKey")
        public Result getKey(HttpSession session){
            Map<String, Key> rsaKey = (Map<String, Key>) session.getAttribute("keys");
            if(rsaKey == null){
                rsaKey = RSAUtil.getRSAKey();
                session.setAttribute("keys",rsaKey);
            }
    
            byte[] encode = Base64Utils.encode(rsaKey.get(RSAUtil.PB_KEY).getEncoded());
            return Result.success(new String(encode));
    
        }
    
        /**
         * 分段解密发送过来的客户端RSA公钥
         * @param map
         * @param session
         * @return
         */
        @RequestMapping("acceptKey")
        public Result acceptKey(@RequestBody Map<String,Object> map, HttpSession session){
    
            List<String> clientKeys = (List<String>) map.get("clientKey");
            System.out.println("clientKey:" + clientKeys);
            Map<String, Key> rsaKey = (Map<String, Key>) session.getAttribute("keys");
    
            String cli_key = "";
            if(clientKeys != null){
                for (String item : clientKeys) {
                    cli_key += RSAUtil.dencByPrKey((PrivateKey) rsaKey.get(RSAUtil.PR_KEY), item);
                }
            }
            session.setAttribute(RSAUtil.CLI_PB_KEY,cli_key);
            System.out.println("解密后客户端公钥:" + cli_key);
            return Result.success();
        }
    
    }
    
    
    package com.lr.demo.controller;
    
    
    import com.alibaba.fastjson.JSON;
    import com.lr.demo.commons.Constant;
    import com.lr.demo.commons.Result;
    import com.lr.demo.util.AESUtil;
    import com.lr.demo.util.RSAUtil;
    import org.springframework.web.bind.annotation.RequestBody;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import java.security.Key;
    import java.security.PrivateKey;
    import java.util.HashMap;
    import java.util.Map;
    
    @RestController
    @RequestMapping("sys")
    public class SystemController {
    
        @RequestMapping("login")
        public Result login(@RequestBody String data, HttpServletRequest request,HttpServletResponse response){
            String plaintext = dencrypt(request, data);
            return Result.success(encrypt("登录成功啦",response));
        }
    
    
        private String dencrypt(HttpServletRequest request,String data){
            // 从session中获取服务端RSA的私钥
            HttpSession session = request.getSession();
            Map<String, Key> rsaKey = (Map<String, Key>) session.getAttribute("keys");
    
            HashMap<String,String> hashMap = JSON.parseObject(data, HashMap.class);
            // 获取客户端发送的加密数据
            String enc_data = hashMap.get(Constant.ENCRYPT_DATA);
            System.out.println("获取请求数据---->:" + enc_data);
            // 获取发送过来的AES秘钥
            String enc_aes_key = request.getHeader(Constant.ENCRYPT_AES_KEY);
            // 解密AES秘钥
            String aes_key = RSAUtil.dencByPrKey((PrivateKey) rsaKey.get(RSAUtil.PR_KEY), enc_aes_key);
            // AES解密
            String plaintext = AESUtil.decrypt(enc_data, aes_key);
    
            System.out.println("解密数据---->:" + plaintext);
            return plaintext;
        }
    
        public Map<String, String> encrypt(String data, HttpServletResponse response){
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            HttpSession session = request.getSession();
            String cliKey = (String) session.getAttribute(RSAUtil.CLI_PB_KEY); // 获取客户端RSA公钥
            String aesKey = AESUtil.getKey(16); // 获取AES秘钥
            // RSA加密AES秘钥
            String encrypt_aes_key = RSAUtil.encByPbKey(cliKey, aesKey);
            // AES加密返回数据
            String encrypt_data = AESUtil.encrypt(data, aesKey);
            // 添加响应头(AES秘钥)
            response.addHeader(Constant.ENCRYPT_AES_KEY, encrypt_aes_key);
            Map<String,String> map = new HashMap<>();
            map.put(Constant.ENCRYPT_DATA,encrypt_data);
            return map;
        }
    }
    
    

    2、前端

    前端涉及的文件较多,这里就只展示下页面,其余详细代码可以下载源码后查看。

    • aes_v1.0.js:AES加解密
    • rsa.js、crypto-js.js:RSA加解密
    • demo.js:封装的函数

    index.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
      <head>
        <title>$Title$</title>
        <script src="static/js/aes_v1.0.js"></script> 
        <script src="static/js/rsa.js"></script>
        <script src="static/js/crypto-js.js"></script>
        <script src="static/js/demo.js"></script>
        <script src="static/js/jquery-3.5.1.js"></script>
      </head>
      <body>
    
      <form action="<%=request.getContextPath()%>/sys/login" id="loginForm">
          <input type="text" name="username" value="">
          <input type="password" name="password" value="">
          <input type="button" value="登录" id="loginBtn">
      </form>
    
      <script>
          // 首页加载时,秘钥生成和交换
          getRsaKeys(f)
      </script>
      
      <script>
    
          function getFormJson(formJqueryObj) {
              var o = {};
              var a = formJqueryObj.serializeArray();
              $.each(a, function () {
                  if (o[this.name]) {
                      if (!o[this.name].push) {
                          o[this.name] = [o[this.name]];
                      }
                      o[this.name].push(this.value || '');
                  } else {
                      o[this.name] = this.value || '';
                  }
              });
              return o;
          }
    
    
          $('#loginBtn').click(function () {
              var json = getFormJson($('#loginForm'))
              // demo.js封装的函数
              request(json,'<%=request.getContextPath()%>/sys/login',function (res) {
                  console.log(res)
              })
          })
      </script>
      </body>
    </html>
    
    

    四、测试

    启动项目,打开首页:
    在这里插入图片描述
    服务端日志:
    在这里插入图片描述

    当交换完秘钥后,进行登录测试:
    在这里插入图片描述
    服务端就收时的日志输出:
    在这里插入图片描述
    响应后页面的输出:
    在这里插入图片描述
    在这里插入图片描述
    以上就是一个简单的demo,源码点击下载

    展开全文
  • 级联-通过多个加密套件进行x混合加密的加密和签名库。 警告:目前,该解决方案应被认为适合研究和实验,在生产应用中使用之前,需要进一步的代码和安全性审查。简介与概述据我们所知,考虑到现有的加密库和...
  • android AES rsa 混合加密

    2017-10-18 12:36:47
    android AES rsa 混合加密
  • DES和RSA混合加密&解密

    2022-03-23 17:15:06
    ​ ...先进行DES加密,将DES加密后的内容进行base64编码,再将base64编码的DES进行RSA加密,本文分别创建DES和RSA工具类,便于单独使用,也可混合使用。
  • 一种基于混合加密算法的文件安全传输方案,郭雅林,马兆丰,针对提供商上传文件到互动多媒体平台过程中文件安全传输的问题,提出了一种混合加密方法。在综合分析了对称加密算法、非对称加密
  • 采用了分析与比较的方法,首先研究了目前常用的对称加密算法DES以及非对称加密算法RSA,然后分析比较了它们的优缺点,进而综合安全性和效率设计出适合于在实际工程中应用的RSA、DES混合加密算法,最后结合实际JAVA...
  • MD5混合加密法2.1版

    2016-08-29 08:51:30
    这个是我写的一个不可逆加密算法【MD5为基础,扩展的一个不可逆加可逆的一个混合算法】这个算法最NB的地方在于同一个数据每次产生的结果都不一致,但都会指向一个正确结果,此算法可以完全阻止表破解,所以适用于...
  • 针对大数据环境中的隐私保护及数据安全问题,综合运用混沌密码和AES算法的优点,提出一种面向大数据的超混沌和AES混合加密方法。利用两个超混沌系统产生的混沌序列,设计一个超混沌分组加密方案;基于Hadoop大数据平台的...
  • 针对云存储服务中数据传输和存储过程对数据的保密性、完整性和不可抵赖性等安全需求,根据云存储的特点,结合AES和RSA传统加密算法特性,提出一种具有身份认证的带干扰混合加密算法。从多个角度对算法进行了安全性...
  • 传统的:Fava类文件加密方式有RSA、AES等,但其对加密长度 是有限制的,在一些较为复杂和长数据加密过程中会存在异常的现象,因此,本 文提出了一种分块Java类文件的RSA加密算法,可有效地...
  • 文中针对云计算的特点,对云计算中数据混合加密算法进行研究。首先分析了传统对称加密算法DES和AES,对其在云计算模型中的优劣进行了对比,然后结合Hadoop分布式计算框架提出了一种DAES混合加密改进算法,该算法通过...
  • 混合加密应用简介

    千次阅读 热门讨论 2021-02-26 08:43:14
    加解密算法分为对称算法加密和非对称算法加密。 对称算法:加解密密钥相同要求发送方和接收方在安全通信之前,商定一个密钥。所以密钥的保密性对通信的安全性至关重要。对称加密算法的特点是算法公开、计算量小、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,602
精华内容 25,040
关键字:

混合加密