精华内容
下载资源
问答
  • 对称加密算法和非对称加密算法的区别 1.对称加密算法加密和解密使用的密钥的是相同的,也就是只有一个密钥,而非...4.还有就是安全性不同,对称加密算法,在传输的过程中被窃听那就玩完了,而非对称加密算法就可以很...

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

    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安全组成 ...对称加密算法——DES 实现方: 主要流程: 代码实现: 对称加密算法——3重DES 3重DES的好处: 3重DES的缺点: 实现方: 代码实现:.

    目录

    简介

    密码常用术语

    密码分类——时间

    密码分类——保密内容算法

    密码分类——密码体制

    密码分类——明文处理方法

    散列函数

    特点:

    散列函数相关的算法

    数字签名

    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——基于离散对数

     

    大家可以动手试一下,其实挺好理解的,大部分实现都是一样,学会一种,就可以举一反三了。

    不足之处,可以关注私信沟通,期待技术交流!

    作者:筱白爱学习!!

    欢迎关注转发评论点赞沟通,您的支持是筱白的动力!

    展开全文
  • 安全架构-加密算法-对称加密

    千次阅读 2020-12-21 21:50:03
    安全架构-加密算法-对称加密 ...本文介绍对称加密算法,后续文章再来介绍非对称加密。 文章目录安全架构-加密算法-对称加密前言一、简介二、特点三、常见算法四、加密填充模式五、加密算法的选择六

    安全架构-加密算法-对称加密

    本系列安全架构文章中,之前谈到了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

    展开全文
  • 密码学安全算法--对称加密算法

    千次阅读 2017-06-04 21:45:50
    最常见对称加密算法是:DES、3DES、AES、RC4。 对称加密算法基本原理 先上图,对称加密工作过程 在整个工作过程中涉及到以下几个概念 - 明文:也就是原始信息或者说原始数据。也就是上图中的A。 - 加密算法...
  • 对称加密算法,非对称加密算法(转)

    千次阅读 2009-05-31 10:49:00
    对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。收信方收到密文后,若想解读原文,则需要...
  • 对称加密算法

    2016-11-22 18:50:25
    对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文(原始数据)和加密密钥(mi yao)一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。收信方收到密文后,若想解读...
  • 对称加密算法

    2018-10-17 14:32:00
    对称加密算法 概述: 对称加密算法在加密和解密时使用的是同一个秘钥; 而非对称加密算法需要两个密钥来进行加密和解密,这两个秘钥是公开密钥(public key,简称公钥)和私有密钥(private key,...
  • 对称加密算法-AES

    2020-02-26 17:44:55
    对称加密(也叫私钥加密, 单密钥加密)指加密和解密使用相同密钥的加密算法,加密密钥和解密密钥是相同的,对称算法的安全性依赖密钥,泄漏密钥就意味着任何人都可以对他们发送或接收的消息解密,所以密钥的保密性...
  • 常用的对称加密算法

    千次阅读 2019-10-26 17:20:38
    需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。 所谓对称,就是采用这种加密方法的双方使用方式用同样的密钥进行加密和...
  • 常见的加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法 对称加密  指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解性...对称加密算法安全性...
  • 对称加密算法是实现安全通信的基本过程,是信息安全不可或缺的部分,它可以帮助客户安全地以比光速还快的速度对数据进行加密。 什么是对称算法及其工作原理? 对称算法是对称密钥加密的核心加密功能。它是计算机执行...
  • 对称加密算法原理简介

    千次阅读 2020-03-15 16:41:41
    对称加密算法使用相同的密钥进行加密和解密,它的计算量小,速度快,是最常用的加密方式,也是密码学和各种安全技术应用的基础。本文主要介绍对称加密算法的基本概念、设计思想和原理。 为什么学习密码学 我原来对...
  •  1、什么是AES加密算法及AES加密算法的形成过程  2、AES的加密流程 (要理解AES的加密流程,会涉及到AES的五个关键词:分组密码体制、Padding、初始向量IV、密钥、四种加密模式)  3、AES的加密原理 (要理解...
  • c#对称加密算法使用

    2020-05-22 19:51:47
    c#中我们经常会对一些敏感的信息进行加密,对称加密算法是一个不错的选择。简单好用。csdn看到博主一蓑烟雨1989的文章,学习一下,很好用。下面介绍一下。 采用单钥密码系统的加密方法,同一个密钥可以同时用作信息...
  • 解读国密非对称加密算法SM2

    千次阅读 2021-01-21 16:44:37
    解读国密非对称加密算法SM2 本文先介绍非对称加密算法,然后聊一聊椭圆曲线密码算法(Elliptic Curve Cryptography,ECC),最后才是本文的主题国密非对称加密算法SM2。因为我的数学知识有限,对于算法涉及的一些...
  • 对称加密算法都会使用加密模式,比如 cbc模式 ecb 模式等。本文介绍四种常见的加密模式:ECB、CBC、CFB、OFB。 电子密码本模式 Electronic Code Book(ECB): 原理如下图: 明文被分成等长的小块(长度取决于...
  • 深入浅出用户认证鉴权使用非对称加密算法加密登录面临的问题明文密码登录MD5/BASE64 加密登录解决方案对称加密与非对称加密对称加密非对称加密在登录过程中的使用 使用非对称加密算法加密登录 面临的问题 明文密码...
  • 常见对称加密算法与工作模式简介

    千次阅读 2019-04-07 22:15:40
    对称密码简介 对称密码(Symmetric Cipher)算法又叫传统密码算法,...对称算法安全性依赖密钥,所以密钥的保密性对通信的安全性至关重要;在安全通信之前,需要有一个安全通道以商定密钥。 加密和解密...
  • 常见的加密算法可以分成三类,对称加密算法,非对称加密算法和Hash算法。 对称加密 指加密和解密使用相同密钥的加密算法。对称加密算法的优点在于加解密的高速度和使用长密钥时的难破解。...对称加密算法安全...
  • 常见非对称加密算法

    万次阅读 2019-04-10 15:14:35
    对称加密技术只使用一个秘钥不同,非对称机密技术使用两个秘钥进行加解密,一个叫做公钥,一个叫做私钥,私钥自己来保管,公钥可以公开,使用公钥加密的数据必须使用私钥解密,反之亦然公钥和私钥是两个不同的秘钥...
  • C#对称加密算法实现及相关类说明

    千次阅读 2015-08-04 11:11:43
    采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。 需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称加密通常在消息发送方需要...
  • AES对称加密算法原理

    千次阅读 2014-10-25 21:42:34
    加密算法使用的轮数要么是10,12,要么是14,这依赖种子密钥长度是128位、192 位还是 256 位。在这个例子中,因为 Nr 等于12, 则这四个操作被调用11次。该迭代完成后,在拷贝 State 矩阵到输出参数前,加密算法...
  • 【AES】——对称加密及AES加密算法

    千次阅读 2019-07-24 11:07:55
     1、什么是AES加密算法及AES加密算法的形成过程  2、AES的加密流程 (要理解AES的加密流程,会涉及到AES的五个关键词:分组密码体制、Padding、初始向量IV、密钥、四种加密模式)  3、AES的加密原理 (要理解...
  • 常见加密算法 : DES(Data Encryption Standard):数据加密标准,速度较快,适用加密大量数据的场合;  3DES(Triple DES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高; RC2和 RC4:...
  • DES加密算法安全性评估

    千次阅读 2011-09-15 10:43:28
    DES加密算法应用误区 DES算法具有极高安全性,到目前为止,除了用穷举搜索法对DES算法进行攻击外,还没有发现更有效的办法。而56位长的密钥的穷举空间为256,这意味着如果一台计算机的速度是每一秒种检测一百万个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,485
精华内容 2,594
关键字:

对称加密算法的安全性取决于