精华内容
下载资源
问答
  • 对称加密与非对称加密
    千次阅读
    2022-03-12 15:51:04

    在现代社会中,我们很多信息都需要通过互联网来传输,这些信息中难免会包含一些私密或者机密的内容,如果直接通过明文传输是非常不安全的,这就需要使用密钥并使用一定的算法对这些明文信息进行加密形成密文后再进行传输,最后接收方对密文进行解密,以获取里面的明文内容,这就涉及到密码学了。

    我们先了解几个概念,虽然很简单,但是对于从未接触过加密的人来说还是有必要提一下的。
    明文: 明文指的是未被加密过的原始数据。
    密文: 明文被某种加密算法加密之后,会变成密文,从而确保原始数据的安全。密文也可以被解密,得到原始的明文。
    密钥: 密钥是一种参数,它是在明文转换为密文或将密文转换为明文的算法中输入的参数。密钥分为对称密钥与非对称密钥,分别应用在对称加密和非对称加密上。

    事实上,密码学出现的非常早,只是早期的密码学基本都是使用替换法移位法进行加密。在之前只用纸和笔进行运算的时代,这些方式或许还是有效的,但在计算机出现之后,这些方法就显得不堪一击了,于是现代密码学应运而生。

    现代密码体制有两种: 对称密码体制( 又称为单钥密码体制) 和非对称密码体制( 又称为双钥密码体制或公钥密码体制) 。

    对称密码体制:使用相同的密钥对消息进行加密或解密,系统的保密性主要由密钥的安全性决定,而与算法是否保密无关。

    对称密码体制设计和实现基本思想是: 用何种方法产生满足保密要求的密钥以及通过何种方法将密钥安全又可靠地分配给通信双方。对称密码体制可以通过分组密码或流密码来实现,它既可以用于数据加密,又可以用于消息认证。

    非对称密码体制:使用公钥加密消息,使用私钥来解密,或使用私钥加密消息,使用公钥进行解密。使用非对称密码体制可增强通信的安全性。

    在密码学体系中,对称加密、非对称加密、单向散列函数、消息认证码、数字签名和伪随机数生成器被统称为密码学家的工具箱。其中,对称加密和非对称加密主要是用来保证机密性;单向散列函数用来保证消息的完整性;消息认证码的功能主要是认证;数字签名保证消息的不可抵赖性。

    对称加密

    对称加密又称单密钥加密,整个加密过程中只使用一个密钥。所谓对称其实就是使用一把密钥加密,并使用同一把密钥进行解密。对称加密由于加解和解密使用的是同一个密钥算法,故而在加解密的过程中速度比较快,适合于数据量比较大的加解密。

    对称加密的优点:算法公开、计算量小、由于使用统一密钥算法所以加密解密速度比较快,适合于数据量比较大的加解密。

    对称加密的缺点:密钥的管理与分配存在风险,一旦泄露,密文内容就会被外人破解;另外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的独一密钥,这会使得收、发双方所拥有的钥匙数量巨大,密钥管理成为双方的负担。

    常用的对称加密算法:DES、3DES、AES、TDEA、Blowfish、RC2、RC4 和 RC5 等

    对称算法适用场景:鉴于其具有更快的运算速度,对称加密在现代计算机系统中被广泛用于保护信息。例如,美国政府使用高级加密标准(AES)来加密和分类和感信息。AES取代了之前的数据加密标准(DES)。

    非对称加密

    非对称加密:在加密过程中,使用密钥对(分别是私钥和公钥。公钥可以对外发布,人人可见。而私钥则自己保管,不外泄)中的一个密钥进行加密,另一个密钥进行解密。比如用公钥加密,那么用私钥解密;用私钥加密,就用公钥来解密。由于加密和解密使用了两个不同的密钥,这就是非对称加密“非对称”的原因。

    非对称加密优点:安全性高,解决了对称加密中密钥管理和分发可能存在不安全的问题。

    非对称加密缺点:加密和解密花费时间长、速度慢,并且由于它们的密钥长度非常长,因此需要更多的计算资源,只适合对少量数据进行加密。

    常用的非对称加密算法:RSA、Elgamal、Rabin、D-H、ECC(椭圆曲线加密算法)等

    非对称加密适用场景:非对称加密通常用于大量用户需要同时加密和解密消息或数据的系统中,尤其是在运算速度和计算资源充足的情况下。该系统的一个常用案例就是加密电子邮件,其中公钥可以用于加密消息,私钥可以用于解密。

    问题:为什么私钥可以解密被公钥加密的数据?
    答:欧拉函数 欧拉定理 互为质数。具体的咱也不懂。

    需要注意的是,在许多应用中,对称和非对称加密会一起使用。这种混合系统的典型案例是安全套接字层(SSL)和传输层安全(TLS)加密协议,该协议被用于在因特网内提供安全通信。SSL协议现在被认为是不安全的,应该停止使用。相比之下,TLS协议目前被认为是安全的,并且已被主流的Web浏览器所广泛使用。

    数字证书

    数字证书有点类似于我们的居民身份证,只是数字证书是基于互联网通信的,用于标记通信双方身份的一种方式。数字证书是由权威机构Certificate Authority发行的,又称之为证书授权,简称为:CA。人们在网上可以根据它来识别对方身份信息。

    数字证书绑定了公钥及其持有者的真实身份,它类似于现实生活中的居民身份证,所不同的是数字证书不再是纸质的证照,而是一段含有证书持有者身份信息并经过认证中心审核签发的电子数据,广泛用在电子商务和移动互联网中。

    数字签名

    除了非对称加密,数字签名也是非对称密码学常见用法。

    数字签名是指将摘要信息使用接收者的公钥进行加密,与密文一起发送给接收者。接收者使用自己的私钥对摘要信息进行解密,然后使用Hash函数对收到的密文产生一个摘要信息,然后将摘要信息与发送着传输过来解密后的摘要信息对比是否一致。如果一致,则表明数据信息没有被篡改。

    也就是说,数字签名能够验证收到的信息的完整性,避免中途信息被劫持篡改或丢失。对方可以根据数字签名来判断获取到的数据信息时候是最原始的数据。

    需要注意,并非所有的数字签名系统都使用加密技术,即使它们用到了公钥和私钥。实际上,可以仅对消息进行数字签名而不进行加密。 RSA是用于对加密消息进行签名的示例算法,但比特币使用的数字签名算法(名为ECDSA)根本没有用到加密功能。

    密钥长度

    对称和非对称加密之间的另一个功能差异与密钥的长度有关,密钥的长度以比特为单位,并且与每个加密算法提供的安全级别直接相关。

    在对称加密中,密钥是随机选择的,其长度通常设置为128或256位,具体长度取决于所需的安全级别。然而,在非对称加密中,公钥和私钥之间在数学上相关联,这意味着两者之间存在算术联系。攻击者可能利用该模式破解密文,因此非对称密钥需要更长的密钥长度,才能提供相同级别的安全性。密钥长度的差异是如此明显,以至于128位的对称密钥和2,048位非对称密钥才能提供大致相同的安全级别。

    更多相关内容
  • C语言实现AES-128对称加解密算法。编译环境:VS2010。请参考我的博客https://blog.csdn.net/u013073067/article/details/86529111 分析代码
  • C语言实现国密SM4对称加解密算法。编译环境:VS2010。请参考我的博客https://blog.csdn.net/u013073067/article/details/86578753 分析代码
  • 对称加密:双方使用的同一个密钥,既可以加密又可以解密,这种加密方法称为对称加密,也称为单密钥加密。 优点:速度快,对称性加密通常在消息发送方需要加密大量数据时使用,算法公开、计算量小、加密速度快、加密...
  • 登录时登录密码进行前端加密,然后传递到后端
  • 主要介绍了Java 对称加密使用DES / 3DES / AES 这三种算法分别实现的相关资料,这里提供了实例代码,需要的朋友可以参考下
  • 6.用对方的公钥对称密钥进行加密加密密钥) 7.将密文(5)和加密密钥(6)一起发给对方 接收方: 1.用自己的私钥对加密密钥进行解密,得到对称密钥--也只有自己才能解密。 2.用对称密钥对密文进行解密,得到...
  • 本文详细介绍了PHP一个简单的对称加密函数实现数据的加密解密,详细的介绍了对称加密和非对称加密,有需要的可以了解一下。
  • 太不安全,应该加密传输,怎么做呢,对称加密一旦秘钥丢失则形同虚设,最好使用非对称加密的方式,由后端事先生成公钥和私钥,公钥发给前端页面,私钥后端自己保留,前端进行认证时,把密码原文用公钥加密再发给后端...
  • 主要介绍了C#对称加密与非对称加密实例,详细分析了对称加密与非对称加密的原理与具体实现方法,具有一定的实用价值,需要的朋友可以参考下
  • 对称加密:DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES 非对称加密:RSA、ECC(移动设备用)、Diffie-Hellman、El Gamal、DSA(数字签名用)
  • 本工具是用于golang编写的,用于rsa非对称加密技术实现的对字符串的加密解密工具,可以对文件进行加密解密(txt、docx、xls文档等)。对文档加密会对文档同目录下生成一个后缀名加.hh的文档。 操作说明: 一、对字符...
  • 最近突发奇想要往数据库里保存一些机密的东西,然后就想着怎么让别人即使进入到了...可是我们自己还要看呢,那只能找一些对称加密的算法了,我们想看的时候再解密回来。下面就介绍了php中简单的对称加密算法实现。
  • 主要介绍了java 非对称加密算法RSA实现详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 基本了解:对称密钥密码加密密钥和解密密钥是相同的。 特点: 1、加密方和解密方使用同一个密钥; 2、加密解密的速度比较快,适合数据比较长时的使用; 3、密钥传输的过程不安全,且容易被破解,密钥管理也...

    基本概念

         未加密消息在密码学中被称为明文

         伪装消息以隐藏消息的过程称为加密

         被加密的消息称为密文

         把密文转换成明文的过程称为解密

    基本了解:对称密钥密码的加密密钥和解密密钥是相同的。

    特点:

    1、加密方和解密方使用同一个密钥;

    2、加密解密的速度比较快,适合数据比较长时的使用;

    3、密钥传输的过程不安全,且容易被破解,密钥管理也比较麻烦;

    优缺点:

    优点:算法公开、计算量小、加密速度快、加密效率高。

    缺点:

    (1)交易双方都使用同样钥匙,安全性得不到保证。

    (2)每对用户每次使用对称加密算法时,都需要使用其他人不知道的惟一钥匙,这会使得发

    收信双方所拥有的钥匙数量呈几何级数增长,密钥管理成为用户的负担。对称加密算法在分

    布式网络系统上使用较为困难,主要是因为密钥管理困难,使用成本较高。 

    常见对称加密算法了解:

    计算机常用的对称密钥加密为分组密码,比较常见的分组密码有DESAESIDEA

    DES加密算法DES是典型的分组密码,使用56位密钥,明文为64位分组序列,共进行16轮的加密,每轮加密都会进行复杂的替换和置换操作,并且每轮加密都会使用一个由56位密钥导出的48位密钥,最终输出与明文等长的64位密文。

    目前,DES已经被证实不是很安全了,屡次被破解,DES的最近一次评估是在1994年,同时决定自199812月以后,DES将不再作为美国联邦加密标准。

    三重DES由于DES密钥只有56位,易于遭受穷举式攻击。作为一种替代加密方案,有人提出使用两个密钥的三重DES加密方法,并在1985年成为美国的一个商用加密标准。该方法使用两个密钥,执行三次DES算法。加密的过程是加密解密加密,解密的过程是解密---加密---解密。

    AESadvanced encryption standard)加密算法:DES逐渐不能适应现代密码安全性需求,就连三种DES也无法适应,于是一种新的密码标准应运而生。

    AES加密过程涉及4种操作:字节替代、行移位、列混淆和轮密钥加。解密过程分别为对应的逆操作。

    AES加密算法的特点

    1. 分组长度和密钥长度均可变(128/192/2561)。
    2. 循环次数允许在一定范围内根据安全奥球进行修正
    3. 汇聚了安全、效率、易用、灵活等优点
    4. 抗线性攻击和抗差分攻击的能力大大增强
    5. 如果1s暴力破解DES,则需要149万亿年破解AES

    IDEA加密算法

    国际数据加密算法(international data encryption algorithm)是1992年提出的非常成功的分组密码,并且广泛应用在安全电子邮件PGP中。

    IDEA加密算法是一个分组长度为64位的分组密码算法,密钥长度为128位,同一个算法即可用于加密,也可用于解密。算法运用硬件与软件实现都很容易,而且比DES算法在实现上快得多。IEDA自问世以来,已经经历了大量的详细审查,对密码分析具有很强的抵抗能力,在很多商业产品中被使用。

    实际使用现状:

     1、DES

    已破解,不再安全,基本没有企业在用了

    是对称加密算法的基石,具有学习价值

    密钥长度56(JDK)、56/64(BC)

     2、DESede(三重DES)

    早于AES出现来替代DES

    计算密钥时间太长、加密效率不高,所以也基本上不用

    密钥长度112/168JDK)、128/192BC)

    3、AES 

     最常用的对称加密算法

    密钥建立时间短、灵敏性好、内存需求低(不管怎样,反正就是好)

    实际使用中,使用工作模式为CTR(最好用BC去实现),此工作模式需要引入IV参数(16位的字节数组)

    密钥长度128/192/256,其中192256需要配置无政策限制权限文件(JDK6)

    填充模式最常用的两种PKCS5PaddingPKCS7Padding,其中后者只有BC独有。

    4、IDEA

     常用的电子邮件加密算法

    工作模式只有ECB

    密钥长度128位   

    参考:计算机网络原理 2018年版本书籍

    https://blog.csdn.net/qq_30054961/article/details/82456069

    展开全文
  • 内容概要:nacos1.1.4版本修改源码使用非对称加密算法RSA进行用户名和密码加密传输。 适用人群:需要适用nacos作为项目注册中心的相关人员、内网用户。 适用场景:linux或者windows系统,使用nacos作为注册中心,...
  • 主要介绍了C#实现简单的RSA非对称加密算法,结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧,需要的朋友可以参考下
  • visual c++ vc实现RSA加密算法是最常用的非对称加密算法.zip
  • 密码学基础分类对称加密对称加密两类加密的特点结合使用举例凯撒密码代码实现-加密代码实现-解密main函数及文件加密 分类 一般分为: 对称加密对称加密 对称加密 加密和解密使用的是同一个密钥或者,两者可以...

    分类

    一般分为:

    • 对称加密
    • 非对称加密

    对称加密

    加密和解密使用的是同一个密钥或者,两者可以互相推导得出,则认为是对称加密,如DES,AES,3DES

    在传输数据时用密钥将数据加密,然后将密文发给接收方,接收方再使用该密钥解密数据。这样就要求接收方需要知道密钥,如果接收方需要接受1万个用户的数据的话就需要知道1万个密钥,并且密钥容易泄漏。

    非对称加密

    加密和解密的密钥不同,且知道其中一个密钥不能得知另一个密钥,一般用来加密的密钥称作公钥,用来解密的密钥称作私钥,如RSA,ECC

    在需要传输数据给某用户时,就使用该用户的公钥对数据加密得到密文发给用户,用户用自己的私钥来解密密文得到数据 。

    两类加密的特点

    • 对称加密安全性差,但是效率高
    • 非对称加密安全性好,但是加密效率低

    结合使用

    在传输一个比较大的数据时,可以先用对称加密来加密数据,对称加密的密钥假如为X,再用非对称加密将X加密。

    举例

    凯撒密码

    凯撒密码是对称密码,其密钥是0-26的一个整数key,加密是将每个字母往后推移key个字母
    比如密钥为3,明文为a,则密文就是d

    代码实现-加密

    //加密
        public static String encryption(String txt,int key){
            if (key<0||key>26)
                return null;
            char[] result=txt.toCharArray();
            int intA=65;
            int inta=97;
            for (int i=0;i<result.length;i++){
                if (result[i]>'A'&&result[i]<'Z') {
                    result[i] =(char)(((int)result[i]+key-intA)%26+intA);
                }else if (result[i]>'a'&&result[i]<'z'){
                    result[i] =(char)(((int)result[i]+key-inta)%26+inta);
                }else;
            }
            return new String(result);
        }
    

    代码实现-解密

    //解密,调用加密的函数
        public static String decrypting(String txt,int key){
            if (key<0||key>26)
                return null;
            return encryption(txt,26-key);
        }
    

    main函数及文件加密

    public static void main(String[] args) {
            Scanner scanner=new Scanner(System.in);
            int choose=0;
            System.out.println("加密输入1,解密输入2:");
            choose=scanner.nextInt();
            if (choose==1){
                System.out.println("输入密钥(0-26):");
                int key=scanner.nextInt();
                String pathname="/new/IdeaProjects/StudyTest/test.txt";
                String oriText=getFileText(pathname);
                String ciphertext=encryption(oriText,key);
                System.out.println(pathname+"加密完成!");
                System.out.println("使用密钥:"+key+"加密后得到密文为:");
                System.out.println(ciphertext);
                String pathname2="/new/IdeaProjects/StudyTest/ciphertext.txt";
                if (printToFile(ciphertext,pathname2)){
                    System.out.println("密文保存在:"+pathname2);
                    return;
                }else {
                    System.out.println("密文保存失败!");
                    return;
                }
            }else if (choose==2){
                System.out.println("输入密钥(0-26):");
                int key=scanner.nextInt();
                String pathname2="/new/IdeaProjects/StudyTest/ciphertext.txt";
                String cipherText=getFileText(pathname2);
                String oriText=decrypting(cipherText,key);
                System.out.println("使用密钥:"+key+"解密完成,明文为:");
                System.out.println(oriText);
    
            }else {
                return;
            }
        }
    
    //读文件
        public static String getFileText(String pathname){
            File file=new File(pathname);
            String str="";
            try {
                Scanner scanner = new Scanner(file);
                while(scanner.hasNext())
                {
                    str=str+" "+scanner.next();
                }
                scanner.close();
            } catch (FileNotFoundException e) {
                System.out.println("file not found.");
            }
            return  str;
        }
    
        //写文件
        public static boolean printToFile(String str,String pathname){
            File file = new File(pathname);// 要写入的文件路径
            if (!file.exists()) {// 判断文件是否存在
                try {
                    file.createNewFile();// 如果文件不存在创建文件
                    System.out.println("文件"+file.getName()+"已为您创建!");
                } catch (IOException e) {
                    System.out.println("创建文件异常!");
                    e.printStackTrace();
                    return false;
                }
            } else {
                System.out.println("文件"+file.getName()+"已存在!");
            }
    
    
            FileOutputStream fos = null;
            PrintStream ps = null;
            try {
                fos = new FileOutputStream(file,true);// 文件输出流	追加
                ps = new PrintStream(fos);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            String string  = str + "\r\n";// +换行
            ps.print(string); // 执行写操作
            ps.close();	// 关闭流
    
            return true;
        }
    
    展开全文
  • 支持Java文件遇见的敏感字段的加密 包括对称和非对称加密
  • * RAS用来加密机密数据:密码/转账资金等等,数据不能呢个太大,否则会非常耗费资源. * 一般随机生成公钥和私钥,用户只需要保存好对应的密钥对,不用关心密码到底是什么. * RAS非对唱加密Java实现: * 1.采用...
  • AES对称加密java工具类

    2020-12-30 19:48:10
    适用于java开发者使用,用于对称加密的数据。进行加密。
  • 自己整理的非对称加密demo,包含生成秘钥文件、生成字符转秘钥两种方式。
  • 在你学习和工作中,经常会用到各种加密算法来保护自己的信息安全,也经常听到对称和非对称加密的概念,可是仔细回想一下,这个对称和非对称到底是怎么来的,怎么个对称法?就自己学习的知识,咋们就来细说一下。 ...

    在你学习和工作中,经常会用到各种加密算法来保护自己的信息安全,也经常听到对称和非对称加密的概念,可是仔细回想一下,这个对称和非对称到底是怎么来的,怎么个对称法?就自己学习的知识,咋们就来细说一下。

    为了理解加密算法,首先需要了解一下几个概念:

    基本概念

    密钥

    密钥(yao 4声),不是秘钥! 百度百科的概念为:密钥是一种参数,它是在明文转换为密文或将密文转换为明文的算法中输入的参数。密钥分为对称密钥与非对称密钥。 可以查看 https://baike.baidu.com/item/密钥/101144?fr=aladdin 说白了就是一种参数,比如一个字符串

    String params = "YouareGreat6666";
    

    公钥

    通过算法得到的一个密钥对(即一个公钥和一个私钥),公钥是密钥对中公开的部分,对所有人都是可见的。

    私钥

    通过算法得到的一个密钥对(即一个公钥和一个私钥),私钥是密钥对中是非公开的部分,只有解密的人才可知。

    通过算法得到的密钥对(公钥-私钥)能保证在世界范围内是独一的。使用这个密钥对的时候,如果用其中一个密钥加密一段数据,必须用另一个密钥解密。比如用公钥加密数据就必须用私钥解密,如果用私钥加密也必须用公钥解密,否则解密将不会成功。
    虽然公钥-私钥对是唯一的,但是我们可以创建无数组公钥-私钥对。

    加密算法

    什么是加密算法,首先加密算法需要满足两个基本的条件:

    1.通过转换需要把明文(人能看得懂的信息) 转成 密文(人看不懂的信息);
    2.能将密文给转回来,与之前明文信息一致。

    所以当有人说MD5是不是加密算法,我个人认为应该不是的,因为MD5算法不可逆,转成了密文,大罗神仙都转不回来了,当然你抬杠要说使用彩虹表碰撞完全可以得到了,算我没说。

    对称加密

    在A和B通信过程中,使用同一个密钥。A给B的密文是 通过加密算法M + 密钥 加密算成 密文, B获取到密文中,使用解密算法N + 密钥的 逆过程,将密文解析回来。大体的图示为:
    在这里插入图片描述
    基本上看图就很容易理解了,就不多说了。

    常用算法

    DES
    56位密钥,现在已经废弃了。

    AES
    128位 192位 256位都有,现在也比较流行。

    下面给出一个AES算法的实现:

    public class AESUtil {
    
        private static final String defaultCharset = "UTF-8";
        private static final String KEY_AES = "AES";
        private static final String KEY = "YouareGreat6666";
        /**
         * 加密
         *
         * @param data 需要加密的内容
         * @param key 加密密码
         * @return
         */
        public static String encrypt(String data, String key) {
            return doAES(data, key, Cipher.ENCRYPT_MODE);
        }
    
        /**
         * 解密
         *
         * @param data 待解密内容
         * @param key 解密密钥
         * @return
         */
        public static String decrypt(String data, String key) {
            return doAES(data, key, Cipher.DECRYPT_MODE);
        }
    
        /**
         * 加解密
         *
         * @param data 待处理数据
         * @param key  密钥
         * @param mode 加解密mode
         * @return
         */
        private static String doAES(String data, String key, int mode) {
            try {
                if (isBlank(data) || isBlank(key)) {
                    return null;
                }
                //判断是加密还是解密
                boolean encrypt = mode == Cipher.ENCRYPT_MODE;
                byte[] content;
                //true 加密内容 false 解密内容
                if (encrypt) {
                    content = data.getBytes(defaultCharset);
                } else {
                    content = parseHexStr2Byte(data);
                }
                //1.构造密钥生成器,指定为AES算法,不区分大小写
                KeyGenerator kgen = KeyGenerator.getInstance(KEY_AES);
                //2.根据ecnodeRules规则初始化密钥生成器
                //生成一个128位的随机源,根据传入的字节数组
                kgen.init(128, new SecureRandom(key.getBytes()));
                //3.产生原始对称密钥
                SecretKey secretKey = kgen.generateKey();
                //4.获得原始对称密钥的字节数组
                byte[] enCodeFormat = secretKey.getEncoded();
                //5.根据字节数组生成AES密钥
                SecretKeySpec keySpec = new SecretKeySpec(enCodeFormat, KEY_AES);
                //6.根据指定算法AES自成密码器
                Cipher cipher = Cipher.getInstance(KEY_AES);// 创建密码器
                //7.初始化密码器,第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作,第二个参数为使用的KEY
                cipher.init(mode, keySpec);// 初始化
                byte[] result = cipher.doFinal(content);
                if (encrypt) {
                    //将二进制转换成16进制
                    return parseByte2HexStr(result);
                } else {
                    return new String(result, defaultCharset);
                }
            } catch (Exception e) {
                System.out.println("error occured" + e);
            }
            return null;
        }
    
        /**
         * 将二进制转换成16进制
         *
         * @param buf
         * @return
         */
        public static String parseByte2HexStr(byte buf[]) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < buf.length; i++) {
                String hex = Integer.toHexString(buf[i] & 0xFF);
                if (hex.length() == 1) {
                    hex = '0' + hex;
                }
                sb.append(hex.toUpperCase());
            }
            return sb.toString();
        }
        /**
         * 将16进制转换为二进制
         *
         * @param hexStr
         * @return
         */
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr.length() < 1) {
                return null;
            }
            byte[] result = new byte[hexStr.length() / 2];
            for (int i = 0; i < hexStr.length() / 2; i++) {
                int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
                int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
                result[i] = (byte) (high * 16 + low);
            }
            return result;
        }
        
        private static boolean isBlank(String key) {
            return null == key || key.trim().length() == 0;
        }
    

    然后可以尝试,进行一下加密和解密:

        public static void main(String[] args) throws Exception {
            String content = "{'phone':'18818881888','password':'12365478965'}";
            
            System.out.println("加密前:" + content);
            System.out.println("加密密钥和解密密钥:" + KEY);
            String encrypt = encrypt(content, KEY);
            System.out.println("加密后:" + encrypt);
            String decrypt = decrypt(encrypt, KEY);
            System.out.println("解密后:" + decrypt);
        }
    

    输出为:
    在这里插入图片描述

    对称加密的缺点

    1. 通信过程中密钥不能备泄漏,如果泄漏了,因为对称算法是固定的,那么加密通信将会失败。

    对称加密的破解方式

    通过上图的输出,我们可以知道,只要知道密钥了,那么系统就被破解了。通常的做法是 获取几组[明文 + 密文],然后通过尝试随机拼凑密钥的方式,通过算法使得明文加密后与密文一致,那么密钥就知道了。
    解决的方式一般就是:

    密钥尽可能复杂,让破解的时间变长。从时间的纬度上讲,对称加密始终会破解的。

    非对称加密

    A与B通信的过程中,使用的是同一套算法M,但是A发送给B的是 使用算法M + 公钥P 生成密文,B获取到密文之后,使用算法M + 私钥Q 解密出明文。大体图如下所示:
    在这里插入图片描述
    虽然看上去比较简单,但是其中实现原理比较复杂,其实存在比较高深的数学知识,我们拿过来就行了。

    常用算法

    RSA算法

    ECDSA算法 又称 椭圆曲线加密算法

    下面提供一种RSA算法的Java例子:
    首先你可能需要下载一个apache包

    public class RSAEncrypt {
    
        private static Map<Integer, String> keyMap = new HashMap<Integer, String>();  //用于封装随机产生的公钥与私钥
    
        /**
         * 随机生成密钥对
         * @throws NoSuchAlgorithmException
         */
        public static void genKeyPair() throws NoSuchAlgorithmException {
            // KeyPairGenerator类用于生成公钥和私钥对,基于RSA算法生成对象
            KeyPairGenerator 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 = new String(Base64.encodeBase64(publicKey.getEncoded()));
            // 得到私钥字符串
            String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));
            // 将公钥和私钥保存到Map
            keyMap.put(0,publicKeyString);  //0表示公钥
            keyMap.put(1,privateKeyString);  //1表示私钥
        }
        /**
         * RSA公钥加密
         *
         * @param str
         *            加密字符串
         * @param publicKey
         *            公钥
         * @return 密文
         * @throws Exception
         *             加密过程中的异常信息
         */
        public static String encrypt( String str, String publicKey ) throws Exception{
            //base64编码的公钥
            byte[] decoded = Base64.decodeBase64(publicKey);
            RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
            //RSA加密
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes("UTF-8")));
            return outStr;
        }
    
        /**
         * RSA私钥解密
         *
         * @param str
         *            加密字符串
         * @param privateKey
         *            私钥
         * @return 铭文
         * @throws Exception
         *             解密过程中的异常信息
         */
        public static String decrypt(String str, String privateKey) throws Exception{
            //64位解码加密后的字符串
            byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
            //base64编码的私钥
            byte[] decoded = Base64.decodeBase64(privateKey);
            RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
            //RSA解密
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, priKey);
            String outStr = new String(cipher.doFinal(inputByte));
            return outStr;
        }
    
    

    然后我们进行测试加密&解密:

        public static void main(String[] args) throws Exception {
            //生成公钥和私钥
            genKeyPair();
            //加密字符串
            String message = "{'phone':'18818881888','password':'12365478965'}";
            System.out.println("随机生成的公钥为:" + keyMap.get(0));
            System.out.println("随机生成的私钥为:" + keyMap.get(1));
    
            String messageEn = encrypt(message,keyMap.get(0));
            System.out.println(message + "\n加密后的字符串为:" + messageEn);
            String messageDe = decrypt(messageEn,keyMap.get(1));
    
            System.out.println("还原后的字符串为:" + messageDe);
        }
    

    运行结果如下:
    在这里插入图片描述
    可以看出,私钥比公钥长太多了。

    非对称加密算法的优缺点

    1. 效率比较低下,相比较于对称加密;
    2. 可靠性比较高,可以在不安全网络上传输密钥。

    破解方式

    与对称加密不同之处的是,非对称加密的公钥很容易获取,因此制造明文 --> 密文是没有难度的。所以非对称加密的关键在于,如果正确的获取到私钥,可以解密所有经过公钥加密过的密文。找到这样的私钥即为成功破解。但是由于非对称加密的自身特性,怎么样通过公钥来推断私钥通常是一种常见的思路,但是往往最佳手段依然是穷举法,只是和对称加密的方式不同区别在于:对称加密需要不断尝试新的密钥来破解明文 -> 密文来进行加密和解密,但是非对称加密需要不断尝试自己的新私钥来判断是否和公钥互相可解。

    总结

    最后一句话概括:对称加密使用同一个密钥,不同的算法;非对称家吗使用不同的密钥,同一套算法。所以我们可以理解为所谓对称,是针对密钥而言的。

    参考目录:
    1.https://blog.csdn.net/qy20115549/article/details/83105736
    2.https://blog.csdn.net/weixin_40784851/article/details/78405245

    展开全文
  • 主要介绍了Java实现的对称加密算法AES,结合实例形式分析了对称加密算法AES的定义、特点、用法及使用场景,需要的朋友可以参考下
  • DES( Data Encryption Standard)算法,于1977年得到美国政府的正式许可,是一种用56位密钥来加密64位数据的方法。
  • 以上学习所有内容,对称加密、非对称加密、消息摘要、数字签名等知识都是为了理解数字证书工作原理而作为一个预备知识。数字证书是密码学里的终极武器,是人类几千年历史总结的智慧的结晶,只有在明白了数字证书工作...
  • RSA非对称加密和DES对称加密代码示例包含(commons-lang3-3.1 commons-codec-1.4.jar)
  • RSA非对称加密算法

    2019-02-14 23:12:03
    主要介绍RSA非对称加密算法的由来和应用场景,以及加密原理
  • 密码学专题 对称加密算法

    千次阅读 2021-11-16 18:02:06
    OpenSSL的对称加密算法指令主要用来对数据进行加密和解密处理,输入输出的方式主要是文件,当然,也可以是默认的标准输入输出设备。 OpenSSL基本上为所有其支持的对称加密算法都提供了指令方式的应用,这些应用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 121,614
精华内容 48,645
关键字:

对称加密是如何进行的