精华内容
下载资源
问答
  • 信息安全基本概念: ECC算法(Elliptic curve cryptography,椭圆曲线密码学) ECC  椭圆加密算法(ECC)是一种公钥加密体制,最初由Koblitz和Miller两人于1985年提出,其数学基础是利用椭圆曲线上的有理点...

    概述

    信息安全基本概念:

    • ECC算法(Elliptic curve cryptography,椭圆曲线密码学

    ECC

      椭圆加密算法(ECC)是一种公钥加密体制,最初由Koblitz和Miller两人于1985年提出,其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。

      是目前已知的公钥体制中,对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用,一般的序列号通常由该算法产生。

      ECC算法在jdk1.5后加入支持,目前仅仅只能完成密钥的生成与解析。 如果想要获得ECC算法实现,需要调用硬件完成加密/解密(ECC算法相当耗费资源,如果单纯使用CPU进行加密/解密,效率低下).

    算法分类信息:

     

    算法 密钥长度 默认长度 签名长度 实现的方
    NONEwithECDSA 112-571 256 128 JDK/BC
    RIPEMD160withECDSA 同上 256 160 BC
    SHA1withECDSA ... 256 160 JDK/BC
    SHA224withECDSA ... 256 224 BC
    SHA256withECDSA ... 256 256 JDK/BC
    SHA384withECDSA ... 256 384 JDK/BC
    SHA512withECDSA ... 256 512 JDK/BC

    签名示例

    复制代码
    import java.security.KeyFactory;  
    import java.security.KeyPair;  
    import java.security.KeyPairGenerator;  
    import java.security.PrivateKey;  
    import java.security.PublicKey;  
    import java.security.Signature;  
    import java.security.interfaces.ECPrivateKey;  
    import java.security.interfaces.ECPublicKey;  
    import java.security.spec.PKCS8EncodedKeySpec;  
    import java.security.spec.X509EncodedKeySpec;  
      
    import com.sun.org.apache.xerces.internal.impl.dv.util.HexBin;  
      
    public class ECDSA {  
        private static String src = "ecdsa security";  
        public static void main(String[] args) {  
            jdkECDSA();  
        }  
          
        public static void jdkECDSA(){  
            try {  
                //1.初始化密钥   
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");  
                keyPairGenerator.initialize(256);  
                KeyPair keyPair = keyPairGenerator.generateKeyPair();  
                ECPublicKey ecPublicKey = (ECPublicKey)keyPair.getPublic();  
                ECPrivateKey ecPrivateKey = (ECPrivateKey)keyPair.getPrivate();  
                  
                  
                //2.执行签名  
                PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());  
                  
                KeyFactory keyFactory = KeyFactory.getInstance("EC");  
                PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);  
                Signature signature = Signature.getInstance("SHA1withECDSA");  
                signature.initSign(privateKey);  
                signature.update(src.getBytes());  
                byte[] res = signature.sign();  
                System.out.println("签名:"+HexBin.encode(res));  
                  
                //3.验证签名  
                X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(ecPublicKey.getEncoded());  
                keyFactory = KeyFactory.getInstance("EC");  
                PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);  
                signature = Signature.getInstance("SHA1withECDSA");  
                signature.initVerify(publicKey);  
                signature.update(src.getBytes());  
                boolean bool = signature.verify(res);  
                System.out.println("验证:"+bool);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
      
    }  
    复制代码

    加解密示例代码

    复制代码
    package com.jd.order.util.encryption;
    
    import java.math.BigInteger;
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.interfaces.ECPrivateKey;
    import java.security.interfaces.ECPublicKey;
    import java.security.spec.ECFieldF2m;
    import java.security.spec.ECParameterSpec;
    import java.security.spec.ECPoint;
    import java.security.spec.ECPrivateKeySpec;
    import java.security.spec.ECPublicKeySpec;
    import java.security.spec.EllipticCurve;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.crypto.Cipher;
    import javax.crypto.NullCipher;
    
    import org.apache.commons.codec.binary.Base64;
    
    import sun.security.ec.ECKeyFactory;
    import sun.security.ec.ECPrivateKeyImpl;
    import sun.security.ec.ECPublicKeyImpl;
    
    @SuppressWarnings("restriction")
    public class ECCCoder {
        public static final String ALGORITHM = "EC";
        private static final String PUBLIC_KEY = "ECCPublicKey";
        private static final String PRIVATE_KEY = "ECCPrivateKey";
    
        /**
         * 解密<br>
         * 用私钥解密
         * 
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] decrypt(byte[] data, String key) throws Exception {
            // 对密钥解密
            byte[] keyBytes = decryptBASE64(key);
    
            // 取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = ECKeyFactory.INSTANCE;
    
            ECPrivateKey priKey = (ECPrivateKey) keyFactory
                    .generatePrivate(pkcs8KeySpec);
    
            ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),
                    priKey.getParams());
    
            // 对数据解密
            // TODO Chipher不支持EC算法 未能实现
            Cipher cipher = new NullCipher();
            // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
            cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());
    
            return cipher.doFinal(data);
        }
    
        /**
         * 加密<br>
         * 用公钥加密
         * 
         * @param data
         * @param privateKey
         * @return
         * @throws Exception
         */
        public static byte[] encrypt(byte[] data, String privateKey)
                throws Exception {
            // 对公钥解密
            byte[] keyBytes = decryptBASE64(privateKey);
    
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = ECKeyFactory.INSTANCE;
    
            ECPublicKey pubKey = (ECPublicKey) keyFactory
                    .generatePublic(x509KeySpec);
    
            ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),
                    pubKey.getParams());
    
            // 对数据加密
            // TODO Chipher不支持EC算法 未能实现
            Cipher cipher = new NullCipher();
            // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
            cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());
    
            return cipher.doFinal(data);
        }
    
        /**
         * 取得私钥
         * 
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static String getPrivateKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
    
            return encryptBASE64(key.getEncoded());
        }
    
        /**
         * 取得公钥
         * 
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static String getPublicKey(Map<String, Object> keyMap)
                throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
    
            return encryptBASE64(key.getEncoded());
        }
    
        /**
         * 初始化密钥
         * 
         * @return
         * @throws Exception
         */
        public static Map<String, Object> initKey() throws Exception {
            BigInteger x1 = new BigInteger(
                    "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);
            BigInteger x2 = new BigInteger(
                    "289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);
    
            ECPoint g = new ECPoint(x1, x2);
    
            // the order of generator
            BigInteger n = new BigInteger(
                    "5846006549323611672814741753598448348329118574063", 10);
            // the cofactor
            int h = 2;
            int m = 163;
            int[] ks = { 7, 6, 3 };
            ECFieldF2m ecField = new ECFieldF2m(m, ks);
            // y^2+xy=x^3+x^2+1
            BigInteger a = new BigInteger("1", 2);
            BigInteger b = new BigInteger("1", 2);
    
            EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);
    
            ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,
                    n, h);
            // 公钥
            ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);
    
            BigInteger s = new BigInteger(
                    "1234006549323611672814741753598448348329118574063", 10);
            // 私钥
            ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);
    
            Map<String, Object> keyMap = new HashMap<String, Object>(2);
    
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
    
            return keyMap;
        }
    
        public static byte[] decryptBASE64(String data) {
            return Base64.decodeBase64(data);
        }
    
        public static String encryptBASE64(byte[] data) {
            return new String(Base64.encodeBase64(data));
        }
    }
    复制代码

        请注意上述代码中的TODO内容,再次提醒注意,Chipher不支持EC算法 ,以上代码仅供参考。Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey均不支持EC算法。为了确保程序能够正常执行,我们使用了NullCipher类,验证程序。 

    测试示例

    复制代码
    package com.jd.order.util.encryption;
    
    import static org.junit.Assert.assertEquals;
    
    import java.util.Map;
    
    import org.junit.Test;
    
    public class ECCCoderTest {
    
        @Test
        public void test() throws Exception {
            String inputStr = "abc";
            byte[] data = inputStr.getBytes();
    
            Map<String, Object> keyMap = ECCCoder.initKey();
    
            String publicKey = ECCCoder.getPublicKey(keyMap);
            String privateKey = ECCCoder.getPrivateKey(keyMap);
            System.err.println("公钥: \n" + publicKey);
            System.err.println("私钥: \n" + privateKey);
    
            byte[] encodedData = ECCCoder.encrypt(data, publicKey);
    
            byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);
    
            String outputStr = new String(decodedData);
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
            assertEquals(inputStr, outputStr);
        }
    
    }
    复制代码

    输出

    复制代码
    公钥: 
    MEAwEAYHKoZIzj0CAQYFK4EEAAEDLAAEAv4TwFN7vBGsqgfXk95ObV5clO7oAokHD7BdOP9YMh8ugAU21TjM2qPZ
    私钥: 
    MDICAQAwEAYHKoZIzj0CAQYFK4EEAAEEGzAZAgEBBBTYJsR3BN7TFw7JHcAHFkwNmfil7w==
    加密前: abc
    
    解密后: abc
    复制代码

    参考文档

    http://snowolf.iteye.com/blog/383412

    http://baike.baidu.com/item/%E6%A4%AD%E5%9C%86%E5%8A%A0%E5%AF%86%E7%AE%97%E6%B3%95/10305582?sefr=cr

    转载于:https://www.cnblogs.com/guweiwei/p/8005816.html

    展开全文
  • 信息安全基本概念: ECC算法(Elliptic curve cryptography,椭圆曲线密码学) 一、ECC加密解密【暂时无意义】  椭圆加密算法(ECC)是一种公钥加密体制,最初由Koblitz和Miller两人于1985年提出,其数学...

    概述

    信息安全基本概念:

    • ECC算法(Elliptic curve cryptography,椭圆曲线密码学

    一、ECC加密解密【暂时无意义】

      椭圆加密算法(ECC)是一种公钥加密体制,最初由Koblitz和Miller两人于1985年提出,其数学基础是利用椭圆曲线上的有理点构成Abel加法群上椭圆离散对数的计算困难性。

      是目前已知的公钥体制中,对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用,一般的序列号通常由该算法产生。

      ECC算法在jdk1.5后加入支持,目前仅仅只能完成密钥的生成与解析。 如果想要获得ECC算法实现,需要调用硬件完成加密/解密(ECC算法相当耗费资源,如果单纯使用CPU进行加密/解密,效率低下).

    代码地址:https://github.com/bjlhx15/algorithm-sign.git  加解密示例代码【仅有理解意义】

    二、ECDSA签名

    基于ECC与DSA签名算法分类信息,ECDSA(elliptic curve digital signature algorithm) 椭圆曲线数字签名算法:速度快,强度高,签名短

    算法 密钥长度 默认长度 签名长度 实现的方
    NONEwithECDSA 112-571 256 128 JDK/BC
    RIPEMD160withECDSA 同上 256 160 BC
    SHA1withECDSA ... 256 160 JDK/BC
    SHA224withECDSA ... 256 224 BC
    SHA256withECDSA ... 256 256 JDK/BC
    SHA384withECDSA ... 256 384 JDK/BC
    SHA512withECDSA ... 256 512 JDK/BC

    签名示例

      代码地址:https://github.com/bjlhx15/algorithm-sign.git

     

    http://baike.baidu.com/item/%E6%A4%AD%E5%9C%86%E5%8A%A0%E5%AF%86%E7%AE%97%E6%B3%95/10305582?sefr=cr

    转载于:https://www.cnblogs.com/bjlhx/p/6564817.html

    展开全文
  • 按照密钥特征的不同,密码体制分为:对称密码体制和非对称密码体制。  按照对明文加密方式的不同,密码体制分为:流密码和分组密码。  非对称密码体制都是分组密码。...流密码的基本加密过程如下...

      按照密钥特征的不同,密码体制分为:对称密码体制非对称密码体制

      按照对明文加密方式的不同,密码体制分为:流密码分组密码

      非对称密码体制都是分组密码。

     

      (1)流密码(又称序列密码),在流密码中,明文以序列的方式表示,称谓明文流。在明文流进行加密

    时,先有种子密钥生成一个密钥流。然后利用加密算法把明文流和密钥流进行加密,产生密流文。流密码的基本加密过程如下图:

    (图片待补充)

     

      (2)分组密码(又称块密码,当密一条长消息时,首相将明文编码表示为二进制序列,然后将其分成若干个固定长度的组

    (最后一组长度的不够,还需要进行补流),最后,在对逐个分组一次进行加密操作。(分组的长短,决定密码的强度)分组密码的保密

    通信如下图:(待补充)

     

      (3)密码系统从原理上分两大类,单密钥系统(又称对称密码系统)双密钥系统(非对称密码系统)

    转载于:https://www.cnblogs.com/BBack/p/9007853.html

    展开全文
  • 然而在学习TLS的协议时,一个难点在于要理解很多密码学的概念...使用对称密码体制的双方都拥有相同的秘钥,任何一方加密的数据都可由对方进行解密,因此如果任何一方的秘钥泄露,则数据将无法保证其安全性。常用的对称

    伴随着到处全网HTTPS的推广,有必要理解下其底层依赖的TSL协议,这是其安全的基石。然而在学习TLS的协议时,一个难点在于要理解很多密码学的概念,而很多像我一样的初学者在遇到这些时都很茫然,所以由必要先了解一些密码学的基本知识。

    两种密码体制

    • 对称秘钥体制
      使用对称密码体制的双方都拥有相同的秘钥,任何一方加密的数据都可由对方进行解密,因此如果任何一方的秘钥泄露,则数据将无法保证其安全性。常用的对称密码方案有:DES,AES等分组加密方式,以及RC系列流式加密方式。
    • 公开秘钥体制
      公开密码体制使用一对秘钥,其中一个秘钥可以对外公开,称为公钥,另一个秘钥需要秘密保存,称为私钥。常见的公开秘钥方案有:Elliptic curve cryptography(ECC), RSA,ElGamal等。

    秘钥交换方案

    • DH方案
      即Diffie–Hellman key exchange,基于有限域上的离散对数难题,允许通信双方在不安全信道上建立共享秘钥。
    • RSA方案
      RSA用作秘钥交换主要是利用”公钥加密的数据只能由对应的私钥进行解密”这个特点,而私钥由对方秘密保管,故外人无法知晓传递的共享秘钥。

    常见的密码学名词

    • DES: Data Encryption Standard,属于分组加密方式,采用64bit的秘钥,曾作为对称秘钥的代表红极一时,被广泛使用,后因秘钥长度过短导致安全性降低,被逐渐废弃。随后衍生出2DES,3DES(表示两重DES,三重DES),采用长度更长的秘钥,安全性也大为增强。不过后来2DES也有安全性问题,因而现在还在使用的是3DES。
    • AES: Advanced Encryption Standard,主要是用来替换DES,秘钥长度可选128/192/256 bit,为现在最广泛使用的对称加密方案。
    • RSA: 公开秘钥方案的典型代表,目前得到广泛使用,用于签名及秘钥交换等场合,其安全性基于大整数的素数分解难题。
    • DSA:数字签名算法,源于ElGamal,虽属于公开秘钥体制,但却只能用于签名的场合,不能用于加解密。原因在于其设计之初的目标就定位于快速的签名,因而不具备类似RSA那样加解密可逆的特点。
    • DH: 也即Diffie–Hellman key exchange,也属于公开秘钥体制,但是主要用于在不安全的信道上建立共享秘钥。DH目前作为主要的秘钥交换方案被广泛使用,但其有一个致命缺点就是容易受到中间人攻击(man in the middle),因此,实际使用时必须结合身份认证方案进行。
    • ECC: 即Elliptic Curve Cryptography, 属于公开秘钥体制,其安全性基于椭圆曲线上的离散对数难题,其相对RSA的优势在于可以用更少的秘钥长度获得相同的安全性能。
    • ECDH: DH方案的一个变种,基于ECC,目前作为秘钥交换的主要方式被广泛使用。
    • ECDSA: DSA方案的一个变种,基于ECC,目前也作为身份认证的主要方案被广泛使用。
    • ECB/CBC:这些属于分组加密方案中的分组操作模式,主要是定义诸如分组不足如何padding,如何反复的作用于其他分组等等。
    展开全文
  • 1、分组密码是对称密码体制。 2、分组密码的作用 - 消息加密 - 消息认证和数据完整性保护 通过用于构造消息认证码(MAC)来实现 构造伪随机数生成器:用于产生性能良好的随机数。 构造流密码 构造其他密码协议的...
  • 加密算法

    2017-02-06 20:23:00
    基本需求及概念 ...对称加密算法是较传统的加密体制,通信双方在加/解密过程中使用他们共享的单一密钥,鉴于其算法简单和加密速度快的优点,目前仍然是主流的密码体制之一。最常用的对称密码算法是数据加密标...
  • Android加密算法

    2017-11-24 15:37:43
    基本需求及概念 ...对称加密算法是较传统的加密体制,通信双方在加/解密过程中使用他们共享的单一密钥,鉴于其算法简单和加密速度快的优点,目前仍然是主流的密码体制之一。最常用的对称密码算法是数
  • 基本需求及概念 ... 对称加密算法是较传统的加密体制,通信双方在加/解密过程中使用他们共享的单一密钥,鉴于其算法简单和加密速度快的优点,目前仍然是主流的密码体制之一。最常用的对称密码算法
  • 常用加密算法的应用

    2019-05-23 08:52:07
    文章目录基本概念密码体制密码破译加密算法对称加密算法非对称加密算法(公钥算法)公钥算法的应用Hash函数(散列函数或摘要函数)Hash函数的应用加密方式流密码参考文献 实际工作和开发过程中,网络通信过程中的数据...
  • 基本概念和原理 存在一个密钥管理中心KMC,其中有一个公钥数据库PKDB,这里存放用户的公钥,权限为共享,即任何人都能查到别人的公钥。 无论是发送方A还是接收方B,都有一个个人公钥Pk和一个个人私钥Sk,公钥用于...
  • 加密和解密过程采用相同的密钥,称为对称密码体制。 ​ 例如将明文分为\(m\)块:\(P_{0},P_{1},P_2,…,P_{m-1}\),每个块在密钥作用下执行相同的变换,生成\(m\)个密文块:\(C_0,C_1,C_2,…,C_{...
  • 基本概念 DES算法:密码体制中的对称密码体制,又被称为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。 明文按64位进行分组,密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40...
  •  首先我们需要区分加密和认证这两个基本概念。 加密是将数据资料加密,使得非法用户即使取得加密过的资料,也无法获取正确的资料内容,所以数据加密可以保护数据,防止监听攻击。其重点在于数据的安全性。身份认证...
  • 公钥、私钥 证书概念

    2016-01-27 15:08:55
    在现代密码体制加密和解密是采用不同的密钥(公开密钥),也就是公开密钥算法(也叫非对称算法、双钥算法)”,每个通信方均需要两个密钥,即公钥和私钥,这两把密钥可以互为加解密。公钥是公开的,不需要保密,而...
  • 1、掌握对称密钥密码体制基本概念; 2、掌握对称密钥密码体制加密/解密的工作原理; 3、重点掌握DES 密码算法加密/解密的基本原理; 4、通过用DES 算法对实际的数据进行加密/解密运算来深刻了解DES 的运行...
  • 信息安全期末复习

    2020-11-29 21:17:06
    1. 信息安全的基本概念是什么? 保护计算机系统的正常运行,具体表现为三个基本属性:保密性、完整性、可用性。 2. 信息安全的基本服务有哪些? 物理安全、网络安全、操作系统安全、软件安全、数据安全 3. 密码体制...
  • TCP/IP学习之路(九)

    2021-04-18 19:44:56
    网络安全 网络安全构成要素 防火墙:基本设计思路都是-》暴露给危险的主机和路由器的个数要有限 ...在这里主要介绍两个概念对称密码体制与公钥密码体制 对称密码体制加密和解密都用相同的密钥。包括AES,
  • 信息安全技术的问答

    2019-10-09 17:29:58
    明文、密文、信道、加密算法、解密算法的基本概念是什么 对称密钥密码体制和典型的算法有哪些 非对称加密算法有哪些 散列函数算法是什么 数字签名与数字水印是什么 密钥分配中心和公钥基础设施是什么 访问...
  • 1.传统密码学,也就是对称密码学,讲述了对称密码学的基本概念以及当代最常用的三重数据加密标准(Triple DES);2.公钥密码学和哈希函数,涉及公钥密码体制基本概念,也讲述了一些数字基础和现在研究热门的椭圆曲线...
  • 密码学概要--JAVA

    2016-08-11 16:59:39
    一、基本概念 ① 密码学五元素:明文,密文,加密算法,解密算法,密钥 ② 对称密码:加解密使用相同密钥的密码体制  非对称密码:加解密使用不同的密钥的密码体制------公钥与私钥 ③ JAVA中的常用类: 1)消息...
  • 应用密码学复习2018

    千次阅读 2018-12-25 17:12:45
    基础概念2. 分组密码3. 数据加密标准4. 分组工作模式(习题)5. 习题(P165)二、公钥密码体制1. 基本原理2. 应用3. 要求4. RSA算法5. RSA的安全性6. 习题(P211) 一、对称密码机制 1. 基础概念 五个基本要素 明文 ...
  • 1.Kerberos&amp;LDAP 简介 (1)Kerberos 是安全认证的概念,该系统设计上采用客户端/服务器结构与 DES、 AES 等加密技术,并且能够进行相互认证,即客户端和...Kerberos 基本概念: 票据授权票据 (TGT Ticket...
  • SSH、公钥和私钥

    2020-06-05 21:09:59
    首先我们需要区分加密和认证这两个基本概念。  加密是将数据资料加密,使得非法用户即使取得加密过的资料,也无法获取正确的资料内容,所以数据加密可以保护数据,防止监听攻击。其重点在于数据的安全性。身份认证...
  • 公钥算法是基于数学函数而不是基于替换和置换 公钥密码是非对称的 ... ... ...一、公钥密码体制基本原理 ...公钥密码学的概念是为了解决传统密码中两个问题提出来...公钥密码体制的6个组成部分:明文、加密算法、公钥、私...
  •  2.2 密码学基本概念  2.2.1 现代密码系统的组成  2.2.2 密码体制  2.2.3 密码算法设计的两个重要原则  2.2.4 密码分析学 . 2.2.5 密码算法的安全性  2.3 对称密码体制  2.3.1 常见的对称密码算法  2.3.2 ...
  • PKI(Public Key Infrastructure,公开密钥体制)是目前比较成熟的安全解决方案,涉及对称密钥加密、数字签名、数字信封等技术,具有很好的安全效果。CA(Certificate Authority,认证中心)是PKI中不可缺少的一部分...
  • C.RSA 算法是一种对称加密算法 D.RSA 的安全性主要基于素因子分解的难度 分组密码有多个工作模式,它们也对保密安全性影响很大,其中,只能用于加密极少量分组 的模式是【A】 A.ECB(电码本) B.OFB(输出反馈)C...

空空如也

空空如也

1 2
收藏数 33
精华内容 13
关键字:

对称加密体制基本概念