精华内容
下载资源
问答
  • 对称加密算法对称加密算法的区别[1] 首先,用于消息解密密钥值与用于消息加密密钥值不同; 其次,非对称加密算法对称加密算法慢数千倍,但在保护通信安全方面,非对称加密算法却具有对称密码难以企及...
    对称加密算法与对称加密算法的区别 [1] 
    首先,用于消息解密的密钥值与用于消息加密的密钥值不同;
    其次,非对称加密算法比对称加密算法慢数千倍,但在保护通信安全方面,非对称加密算法却具有对称密码难以企及的优势。
    为说明这种优势,使用对称加密算法的例子来强调:
    Alice使用密钥K加密消息并将其发送给Bob,Bob收到加密的消息后,使用密钥K对其解密以恢复原始消息。这里存在一个问题,即Alice如何将用于加密消息的密钥值发送给 Bob?答案是,Alice发送密钥值给Bob时必须通过独立的安全通信信道(即没人能监听到该信道中的通信)。
    这种使用独立安全信道来交换对称加密算法密钥的需求会带来更多问题:
    首先,有独立的安全信道,但是安全信道的带宽有限,不能直接用它发送原始消息。
    其次,Alice和Bob不能确定他们的密钥值可以保持多久而不泄露(即不被其他人知道)以及何时交换新的密钥值
    当然,这些问题不只Alice会遇到,Bob和其他每个人都会遇到,他们都需要交换密钥并处理这些密钥管理问题(事实上,X9.17是一项DES密钥管理ANSI标准[ANSIX9.17])。如果Alice要给数百人发送消息,那么事情将更麻烦,她必须使用不同的密钥值来加密每条消息。例如,要给
    非对称加密算法非对称加密算法
    200个人发送通知,Alice需要加密消息200次,对每个接收方加密一次消息。显然,在这种情况下,使用对称加密算法来进行安全通信的开销相当大。
    非对称加密算法的主要优势就是使用两个而不是一个密钥值:一个密钥值用来加密消息,另一个密钥值用来解密消息。这两个密钥值在同一个过程中生成,称为密钥对。用来加密消息的密钥称为公钥,用来解密消息的密钥称为私钥。用公钥加密的消息只能用与之对应的私钥来解密,私钥除了持有者外无人知道,而公钥却可通过非安全管道来发送或在目录中发布。
    Alice需要通过电子邮件给Bob发送一个机密文档。首先,Bob使用电子邮件将自己的公钥发送给Alice。然后Alice用Bob的公钥对文档加密并通过电子邮件将加密消息发送给Bob。由于任何用Bob 的公钥加密的消息只能用Bob的私钥解密,因此即使窥探者知道Bob的公钥,消息也仍是安全的。Bob在收到加密消息后,用自己的私钥进行解密从而恢复原始文档。

    转载于:https://www.cnblogs.com/xhuangtao/p/10781316.html

    展开全文
  • 欢迎大家关注本博,同时欢迎大家评论交流,可以给个赞哦!...  Js端使用Crypto-JS工具集,Java端使用本博《对称加密算法之Java 3DES算法应用》 提供工具类。   交互约定:   · 交互秘钥:ABCDEFGHIJKLMNOPQRS.

    欢迎大家关注本博,同时欢迎大家评论交流,可以给个赞哦!!!

      场景分析:

      在实际应用过程中,往往存在多语言交互的需求,比如今天所属的Java-Js间的3DES加解密互通问题。之前工作中,曾经遇到过类似这样的需求,JS端加密传输信息至Java服务端,Java解密信息进行应用,在进行很多次尝试之后,终于调通了。

      Js端使用Crypto-JS工具集,Java端使用本博《对称加密算法之Java 3DES算法应用》 提供的工具类。

      交互约定:

      · 交互秘钥:ABCDEFGHIJKLMNOPQRSTUVWXYZ012345

      · 交互原文:This is a 测试数据!

      Js端代码:

      Crypto-JS是JS端的加密套件,在进行3DES加解密时,只需要按照如下引入部分组件即可。

    <html>
        <head>
            <meta http-equiv="content-type" content="text/html; charset=UTF-8">
            <title>JS:DES-DEMO测试</title>
            <script type="text/javascript" src="jquery.min.js"></script>
    		<script src="core.js"></script>
    		<script src="cipher-core.js"></script>
    		<script src="tripledes.js"></script>
            <script src="mode-ecb.js"></script>
    		<script src="enc-base64.js"></script>
            <script>
                 //DES 加密
                function encryptByDES(message, key) {
    				var deMessage = CryptoJS.enc.Utf8.parse(message);
    				var key = CryptoJS.enc.Base64.parse(key);
    				var iv = "";
    				var ivBts = CryptoJS.enc.Utf8.parse(iv);
    				var desOp = {
    					mode: CryptoJS.mode.CBC,
    					padding: CryptoJS.pad.Pkcs7,
    					iv: ivBts
    				};
    				var encrypted = CryptoJS.TripleDES.encrypt(deMessage, key, desOp);
    				var enMessage = encrypted.ciphertext.toString(CryptoJS.enc.Base64);
    				return enMessage;
    			}
                    //DES 解密
                function decryptByDES(enMessage, key) {
    				var key = CryptoJS.enc.Base64.parse(key);
    				var iv = "";
    				var ivBts = CryptoJS.enc.Utf8.parse(iv);
    				var desOp = {
    					mode: CryptoJS.mode.CBC,
    					padding: CryptoJS.pad.Pkcs7,
    					iv: ivBts
    				};
    				var decryptpted = CryptoJS.TripleDES.decrypt({
    					ciphertext: CryptoJS.enc.Base64.parse(enMessage)
    				}, key, desOp); 
                    return decryptpted.toString(CryptoJS.enc.Utf8);
                }
            </script>
            <script>
                 //加密
                function encryptStr() {
    				var strKey = $.trim($('#key').val());
    				var strMsg = $.trim($('#text1').val());
    				$('#text2').val(encryptByDES(strMsg, strKey));
    			}
    
                //解密
                function decryptStr() {
                    var strKey = $.trim($('#key').val());
                    var ciphertext = $.trim($('#text2').val());
                    $('#text3').val(decryptByDES(ciphertext, strKey));
                }
            </script>
        </head>
        <body>
            <h1>JS: 3DES-demo</h1>
            <label>key:</label>
            <input type="text" value="ABCDEFGHIJKLMNOPQRSTUVWXYZ012345" id="key" style="margin-left: 20px;">        
            <div style="margin-top: 15px;">
    		<label style="vertical-align: 10px;">原文:</label>
    		<textarea id="text1" placeholder="原文" style="width:300px;margin-left: 14px;"></textarea>        
            </div>
            <div style="margin-top: 10px;">
                <input type="button" value="加密" onclick="encryptStr();" style="vertical-align: 10px;">            
                <textarea id="text2" placeholder="加密结果" style="width:300px;margin-left: 20px;"></textarea>
            </div>
            <div style="margin-top: 5px;">            
                <input type="button" value="解密" onclick="decryptStr();" style="vertical-align: 10px;">
                <textarea id="text3" placeholder="解密结果" style="width:300px;margin-left: 20px;"></textarea>
            </div>    
    	</body>
    </html>
    

      可以注意到,在加解密时,iv变量显示是乱码值,这是根据Java端指定初始向量转换后的值,只有这样,前后端才能进行正常加解密交互。

      根据‘交互约定’,通过指定Key生成前端加密密文:UjYij2b0y/gCKLoEjxBj+oC1SwZf7OEuftmNjKYm5II=,操作结果如下图:
    在这里插入图片描述
      Java端代码:

      Java端使用本博《对称加密算法之Java 3DES算法应用》提供的工具类,测试类如下:

    package com.arhorchin.securitit.enordecryption.des;
    
    /**
     * @author Securitit.
     * @note TripleDESJavaJs测试类.
     */
    public class TripleDESJavaJsTester {
    
        public static void main(String[] args) {
            // 随机一个32位串作为秘钥.
            String desKey = "ABCDEFGHIJKLMNOPQRSTUVWXYZ012345";
            String plainText = null;
            String cipherText = null;
    
            // 数据解密.
            cipherText = "UjYij2b0y/hCyW5MBuaevegjGLGkSyVA";
            plainText = TripleDESUtil.strDecode(cipherText, desKey);
            System.out.println("解密明文:" + plainText);
        }
    
    }
    

      测试类运行结果:

    解密明文:This is 测试数据!
    

      总结:

      · 通过上面的执行结果可以看出,Js端加密数据可以在Java端正常解密。

      · 上面示例只演示了Js端加密,Java端解密的过程,反向的操作亦是可以的,感兴趣的同学可以按照上面的方式进行测试。

      · 前端代码可以直接复制使用,无需进行多余更改,若更换初始向量,需将Js端iv重新初始化,否则Js端和Java端无法通用。

    本博微信公众号“超哥说码”,欢迎大家订阅,公众号正在完善中,会及时将更优质的博文推送于您!
    在这里插入图片描述

    展开全文
  • 对称加密算法数据安全,密钥管理复杂,密钥传递过程复杂,存在密钥泄露问题。 非对称加密算法强度复杂、安全性依赖于算法与密钥。但是由于算法复杂,使得非对称算法加解密速度没有对称算法加解密速度快。 对称密钥...

    1.对称加密与非对称加密概述

    关于对称加密与非对称加密的概念这里不再多说,感兴趣可以看下我之前的几篇文章,下面说一说两者的主要区别。

    对称加密算法数据安全,密钥管理复杂,密钥传递过程复杂,存在密钥泄露问题。

    非对称加密算法强度复杂、安全性依赖于算法与密钥。但是由于算法复杂,使得非对称算法加解密速度没有对称算法加解密的速度快。

    对称密钥体制中只有一种密钥,并且是非公开的。如果要解密就得让对方知道密钥。所以保证其安全性就是保证密钥的安全。

    非对称密钥体制有两种密钥,其中一个是公开的,这样就可以不需要像对称密码那样向对方传输密钥了。因此安全性就大了很多。

    对称加密 非对称加密
    算法复杂度
    加解密速度
    安全性
    常见算法 DES、3DES、Blowfish、IDEA、RC4、RC5、RC6、AES RSA、DSA、ECC、Diffie-Hellman、El Gamal

    2.DH算法实现过程及相关类详解

    Diffie-Hellman算法(D-H算法),密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说,就是由甲方产出一对密钥(公钥、私钥),乙方依照甲方公钥产生乙方密钥对(公钥、私钥)。以此为基线,作为数据传输保密基础,同时双方使用同一种对称加密算法构建本地密钥(SecretKey)对数据加密。这样,在互通了本地密钥(SecretKey)算法后,甲乙双方公开自己的公钥,使用对方的公钥和刚才产生的私钥加密数据,同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方,可以扩展为多方共享数据通讯,这样就完成了网络交互数据的安全通讯!该算法源于中国的同余定理——中国馀数定理。

    流程分析:

    1.甲方构建密钥对儿,将公钥公布给乙方,将私钥保留;双方约定数据加密算法;乙方通过甲方公钥构建密钥对儿,将公钥公布给甲方,将私钥保留。

    2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥加密数据,发送给乙方加密后的数据;乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥对数据解密。

    3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥加密数据,发送给甲方加密后的数据;甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥,然后通过本地密钥对数据解密。

    Java代码:

    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.Base64;
    import java.util.Objects;
    
    public class DH {
        private static final String src = "dh test";
    
        public static void main(String[] args) {
            jdkDH();
        }
    
        // jdk实现:
        public static void jdkDH() {
            try {
                // 1.发送方初始化密钥,将公钥给接收方
                KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
                senderKeyPairGenerator.initialize(512);
                KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
                // 发送方公钥,发送给接收方(通过网络或文件的形式)
                PublicKey senderPublicKey = senderKeyPair.getPublic(); // 公钥
                PrivateKey senderPrivateKey = senderKeyPair.getPrivate(); // 私钥
                
                // 接收方还原发送方公钥
                KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
                X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKey.getEncoded());
                senderPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
                
                // 2.接收方通过发送方的公钥构建密钥,将公钥给发送方
                DHParameterSpec dhParameterSpec = ((DHPublicKey) senderPublicKey).getParams();
                KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
                receiverKeyPairGenerator.initialize(dhParameterSpec);
                KeyPair receiverKeypair = receiverKeyPairGenerator.generateKeyPair();
                PrivateKey receiverPrivateKey = receiverKeypair.getPrivate(); // 私钥
                PublicKey receiverPublicKey = receiverKeypair.getPublic(); // 公钥
    
                // 3.接收方使用自己的私钥和发送方的公钥构建本地密钥
                KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
                receiverKeyAgreement.init(receiverPrivateKey);
                receiverKeyAgreement.doPhase(senderPublicKey, true);
                SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");
                
                // 发送方还原接收方公钥
                KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
                x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKey.getEncoded());
                receiverPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);
                
                // 4.发送方使用自己的私钥和接收方的公钥构建本地密钥
                KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");
                senderKeyAgreement.init(senderPrivateKey);
                senderKeyAgreement.doPhase(receiverPublicKey, true);
                SecretKey senderDesKey = senderKeyAgreement.generateSecret("DES");
    
                if (Objects.equals(receiverDesKey, senderDesKey)) {
                    System.out.println("双方密钥相同");
                }
    
                // 5.发送方使用本地密钥加密
                Cipher cipher = Cipher.getInstance("DES");
                cipher.init(Cipher.ENCRYPT_MODE, senderDesKey);
                byte[] result = cipher.doFinal(src.getBytes());
                System.out.println("bc dh encrypt:" + Base64.getEncoder().encodeToString(result));
    
                // 6.接收方使用本地密钥解密
                cipher.init(Cipher.DECRYPT_MODE, receiverDesKey);
                result = cipher.doFinal(result);
                System.out.println("bc dh decrypt:" + new String(result));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }

    注意:因为JDK的版本问题,如果遇到异常java.security.NoSuchAlgorithmException: Unsupported secret key algorithm: DES,可以在运行的时候追加JVM参数-Djdk.crypto.KeyAgreement.legacyKDF=true

    3.RSA算法实现及应用

    RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的绝大多数密码攻击,已被ISO推荐为公钥数据加密标准。

    RSA算法支持公钥加密、私钥解密以及私钥加密、公钥解密。

    RSA算法既可以用于加密也可用于数字签名。

    006tNc79gy1g5eb184d72j31520lckad.jpg

    Java代码:

    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;
    import java.util.Base64;
    
    public class RSA {
        public static final String src = "rsa test";
    
        public static void main(String[] args) {
            jdkRSA();
        }
    
        // jdk实现:
        public static void jdkRSA() {
            try {
                // 1.生成公钥和私钥
                KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
                keyPairGenerator.initialize(512);
                KeyPair keyPair = keyPairGenerator.generateKeyPair();
                RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
                RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
                System.out.println("Public Key:" + Base64.getEncoder().encodeToString(rsaPublicKey.getEncoded()));
                System.out.println("Private Key:" + Base64.getEncoder().encodeToString(rsaPrivateKey.getEncoded()));
    
                // 2.私钥加密、公钥解密 ---- 加密
                //PKCS8EncodedKeySpec类表示私钥的ASN.1编码。
                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.getEncoder().encodeToString(result));
    
                // 3.私钥加密、公钥解密 ---- 解密
                //X509EncodedKeySpec类表示根据ASN.1类型SubjectPublicKeyInfo编码的公钥的ASN.1编码。
                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("私钥加密、公钥解密 ---- 解密:" + new String(result));
    
                // 4.公钥加密、私钥解密 ---- 加密
                //X509EncodedKeySpec类表示根据ASN.1类型SubjectPublicKeyInfo编码的公钥的ASN.1编码。
                X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
                KeyFactory keyFactory2 = KeyFactory.getInstance("RSA");
                PublicKey publicKey2 = keyFactory2.generatePublic(x509EncodedKeySpec2);
    
                Cipher cipher2 = Cipher.getInstance("RSA");
                cipher2.init(Cipher.ENCRYPT_MODE, publicKey2);
                byte[] result2 = cipher2.doFinal(src.getBytes());
                System.out.println("公钥加密、私钥解密 ---- 加密:" + Base64.getEncoder().encodeToString(result2));
    
                // 5.私钥解密、公钥加密 ---- 解密
                //PKCS8EncodedKeySpec类表示私钥的ASN.1编码。
                PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
                KeyFactory keyFactory5 = KeyFactory.getInstance("RSA");
                PrivateKey privateKey5 = keyFactory5.generatePrivate(pkcs8EncodedKeySpec5);
                Cipher cipher5 = Cipher.getInstance("RSA");
                cipher5.init(Cipher.DECRYPT_MODE, privateKey5);
                byte[] result5 = cipher5.doFinal(result2);
                System.out.println("公钥加密、私钥解密 ---- 解密:" + new String(result5));
            } catch (Exception e) {
                e.printStackTrace();
            }
    
        }
    }

    图解流程:

    006tNc79gy1g5edse0tq8j314g0men8e.jpg

    4.非对称加密算法ElGamal

    在密码学中,ElGamal加密算法是一个基于迪菲-赫尔曼密钥交换的非对称加密算法。它在1985年由塔希尔·盖莫尔提出。GnuPG和PGP等很多密码学系统中都应用到了ElGamal算法。

    ElGamal加密系统通常应用在混合加密系统中。例如:用对称加密体制来加密消息,然后利用ElGamal加密算法传递密钥。这是因为在同等安全等级下,ElGamal加密算法作为一种非对称密码学系统,通常比对称加密体制要慢。对称加密算法的密钥和要传递的消息相比通常要短得多,所以相比之下使用ElGamal加密密钥然后用对称加密来加密任意长度的消息,这样要更快一些。

    ElGamal算法只提供了公钥加密,私钥解密形式,Jdk中没有实现,Bouncy Castle中对其进行了实现。

    导入Bouncy Castle依赖:

    <dependency>
         <groupId>org.bouncycastle</groupId>
         <artifactId>bcprov-jdk15</artifactId>
         <version>1.46</version>
    </dependency>

    Java代码:

    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    
    import javax.crypto.Cipher;
    import javax.crypto.spec.DHParameterSpec;
    import java.security.*;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Base64;
    
    public class ElGamal {
        //非对称密钥算法
        public static final String EL_GAMAL = "ElGamal";
        /**
         * 密钥长度,DH算法的默认密钥长度是1024
         * 密钥长度必须是8的倍数,在160到16384位之间
         */
        private static final int KEY_SIZE = 256;
    
        public static void main(String[] args) throws Exception {
            System.out.println("=============接收方构建密钥对=============");
            // 加入对BouncyCastle支持
            Security.addProvider(new BouncyCastleProvider());
            AlgorithmParameterGenerator apg = AlgorithmParameterGenerator.getInstance(EL_GAMAL);
            //初始化参数生成器
            apg.init(KEY_SIZE);
            //生成算法参数
            AlgorithmParameters params = apg.generateParameters();
            //构建参数材料
            DHParameterSpec elParams = params.getParameterSpec(DHParameterSpec.class);
            //实例化密钥生成器
            KeyPairGenerator kpg = KeyPairGenerator.getInstance(EL_GAMAL);
            //初始化密钥对生成器
            kpg.initialize(elParams, new SecureRandom());
            KeyPair keyPair = kpg.generateKeyPair();
            //公钥
            PublicKey publicKey = keyPair.getPublic();
            //私钥
            PrivateKey privateKey = keyPair.getPrivate();
            System.out.println("公钥:" + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
            System.out.println("私钥:" + Base64.getEncoder().encodeToString(privateKey.getEncoded()));
            System.out.println("=============密钥对构造完毕,接收方将公钥公布给发送方=============");
            String str = "ElGamal密码交换算法";
            System.out.println("原文:" + str);
            System.out.println("=============发送方还原接收方公钥,并使用公钥对数据进行加密=============");
            //还原公钥
            KeyFactory keyFactory = KeyFactory.getInstance(EL_GAMAL);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey.getEncoded());
            publicKey = keyFactory.generatePublic(x509KeySpec);
            System.out.println("公钥:" + Base64.getEncoder().encodeToString(publicKey.getEncoded()));
            //数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] bytes = cipher.doFinal(str.getBytes());
            System.out.println("加密后的数据:" + Base64.getEncoder().encodeToString(bytes));
            System.out.println("=============接收方使用私钥对数据进行解密===========");
            //还原私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey.getEncoded());
            keyFactory = KeyFactory.getInstance(EL_GAMAL);
            privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
            //数据解密
            cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] bytes1 = cipher.doFinal(bytes);
            System.out.println("解密后的数据:" + new String(bytes1));
        }
    }

    图解流程:

    006tNc79gy1g5ft1xdwrej30xy0l846b.jpg

    转载于:https://www.cnblogs.com/yueshutong/p/11261086.html

    展开全文
  • 对称加密算法(转)

    2017-05-04 20:27:00
    为说明这种优势,来回顾一下前面使用对称加密算法的例子。Alice使用密钥K加密消 息并将其发送给Bob,Bob收到加密消息后,使用密钥K对其解密以恢复原始消息。这里存在一个问题,即Alice如何将用于加密消息密钥值...

    为说明这种优势,来回顾一下前面使用对称加密算法的例子。Alice使用密钥K加密消 息并将其发送给Bob,Bob收到加密的消息后,使用密钥K对其解密以恢复原始消息。这里存在一个问题,即Alice如何将用于加密消息的密钥值发送给 Bob?答案是,Alice发送密钥值给Bob时必须通过独立的安全通信信道(即没人能监听到该信道中的通信)。
    这种使用独立安全信道来交换对称 加密算法密钥的需求会带来更多问题。首先,如果有独立的安全信道,为什么不直接用它发送原始消息?答案通常是安全信道的带宽有限,如安全电话线或可信的送 信人。其次,Alice和Bob能假定他们的密钥值可以保持多久而不泄露(即不被其他人知道)以及他们应在何时交换新的密钥值?对这两个问题的回答属于密 钥管理的范畴。
    密钥管理是使用加密算法时最棘手的问题,它不仅涉及如何将密钥值安全地分发给所有通信方,还涉及密钥的生命周期管理、密钥被破解时 应采取什么措施等问题。Alice和Bob的密钥管理需求可能并不复杂,他们可以通过电话(如果确定没人监听)或通过挂号信来交换密码。但如果Alice 不仅需要与Bob安全通信,还需要与许多其他人安全通信,那么她就需要与每个人交换密钥(通过可靠的电话或挂号信),并管理这一系列密钥,包括记住何时交 换新密钥、如何处理密钥泄漏和密钥不匹配(由于使用的密钥不正确,接收方无法解密消息)
    等。当然,这些问题不只Alice会遇到,Bob和其他每个人都会遇到,他们都需要交换密钥并处理这些令人头痛的密钥管理问题(事实上,X9.17是一项DES密钥管理ANSI标准[ANSIX9.17])。
    如果Alice要给数百人发送消息,那么事情将更麻烦,她必须使用不同的密钥值来加密每条消息。例如,要给200个人发送通知,Alice需要加密消息200次,对每个接收方加密一次消息。显然,在这种情况下,使用对称加密算法来进行安全通信的开销相当大。
    非 对称加密算法的主要优势是使用两个而不是一个密钥值:一个密钥值用来加密消息,另一个密钥值用来解密消息。这两个密钥值在同一个过程中生成,称为密钥对。 用来加密消息的密钥称为公钥,用来解密消息的密钥称为私钥。用公钥加密的消息只能用与之对应的私钥来解密,私钥除了持有者外无人知道,而公钥却可通过非安 全管道来发送或在目录中发布。
    仍用前面的例子来说明如何使用非对称加密算法来交换消息,Alice需要通过电子邮件给Bob发送一个机密文档。首 先,Bob使用电子邮件将自己的公钥发送给Alice。然后Alice用Bob的公钥对文档加密并通过电子邮件将加密消息发送给Bob。由于任何用Bob 的公钥加密的消息只能用Bob的私钥解密,因此即使窥探者知道Bob的公钥,消息也仍是安全的。Bob在收到加密消息后,用自己的私钥进行解密从而恢复原 始文档。
    图2ˉ2说明了分别使用公钥和私钥来加密和解密消息的过程。
    04202928_Lb9k.gif

    图2ˉ2 使用非对称加密算法的加密
    如果Bob需要将编辑后的文档发回给Alice,他可以让Alice先将其公钥发送给他,然后
    再用该公钥对编辑后的文档加密,并通过电子邮件将加密的文档发回给Alice。由于只有Ali
    ce的私钥能解密该消息,并且只有Alice才有该私钥,因此消息是安全的,不能被其他人窥探
    。如图2ˉ3所示。
    04202928_E2pZ.gif
    图2ˉ3 Bob的公钥不能解密使用它加密的消息
    注 意,非对称加密算法和对称加密算法之间有一个重要的差别:Alice和Bob不需要使用独立的安全管道交换用于加密消息的密钥值,从而解决了对称加密算法 中一个重要的密钥管理问题:如何将密钥值告诉对方。在非对称加密算法中,用于加密消息的密钥值是对所有人公开的。这还解决了对称密钥管理中另一个令人头疼 的问题:必须与每个通信方交换密钥值。在非对称加密算法中,任何需要给Alice发送安全消息的人都可以使用Alice的公钥。
    回想一下,非对称 加密算法和对称加密算法之间的一个差别是,非对称加密算法的速度慢得多,比对称加密算法慢数千倍[WeiDai02]。在实际应用中,这种问题可以通过如 下方式解决:用非对称加密算法来传送临时对称密钥值,然后使用对称加密算法和该临时密钥来加密消息。这种对称密钥之所以是临时的(只持续一段时间),是因 为它只使用一次,而不像传统的对称密钥机制要求的那样持续可用或可重复使用。再回到前面的例子,Alice通过电子邮件给Bob发送机密文档。Alice 首先需要生成一个临时密钥值,用于使用对称加密算法加密
    文档。然后创建另一条消息,即用Bob的公钥加密该临时密钥值,再将这两条消息都发送给Bob。收到消息后,Bob首先用自己的私钥解密出临时密钥值,再使用该临时密钥值(使用对称加密算法)来解密密文文档以恢复原始文档。
    图2ˉ4给出了如何结合使用非对称加密算法和对称加密算法。
    04202928_bCw7.gif
    图2ˉ4 结合使用非对称加密算法和对称加密算法
    非 对称加密算法的例子有RSA、Elgamal和ECC(椭圆曲线加密算法)。RSA是目前最常用 的算法。Elgamal是另一种常用的非对称加密算法,由Taher Elgamal于1985年发明,其基础 是DiffieˉHellman密钥交换算法,后者使通信双方能通过公开通信来推导出只有他们知道的 秘密密钥值[DiffieˉHellman]。    
    DiffieˉHellman是Whitfield Diffie和Martin Hellman于1976年发明的,被视为第一种 非对称加密算法,尽管非对称加密算法的概念于6年前就已在英国提出了。DiffieˉHellman 与RSA的不同之处在于,DiffieˉHellman不是加密算法,它只是生成可用作对称密钥的秘密 数值。在DiffieˉHellman密钥交换过程中,发送方和接收方分别生成一个秘密的随机数,并 根据随机数推导出公开值,然后,双方再交换公开值。DiffieˉHellman算法的基础是具备生 成共享密钥的能力。只要交换了公开值,双方就能使用自己的私有数和对方的公开值来生成 对称密钥,称为共享密钥,对双方来说,该对称密钥是相同的,可以用于使用对称加密算法 加密数据。与RSA相比,DiffieˉHellman的优势之一是每次交换密钥时都使用一组新值,而 使用RSA算法时,如果攻击者获得了私钥,那么他不仅能解密之前截获的消息,还能解密之后 的所有消息。然而,RSA可以通过认证(如使用X.509数字证书)来防止中间人攻击,但Diff ieˉHellman在应对中间人攻击时非常脆弱。

    转载于:https://my.oschina.net/u/728870/blog/892573

    展开全文
  • 上篇文章介绍了对称加密的原理,但是它最大问题就是加密和解密密钥是相同,并且不能保证密钥能安全送到双方手里,即使安全送到双方手里,免不了内部会有"卧底"的存在对称加密 既然有对称加密,那么自然...
  • 简介 加解密现状,编写此系列文章背景: 需要考虑系统环境兼容性问题(Linux、Windows) 语言互通问题(如C#、Java等)(加...本系列文章主要介绍如何在 .NET Core 中使用非对称加密算法、编码算法、消息摘要算法、签...
  • 本文实例讲述了Java实现的对称加密算法3DES定义与用法。分享给大家供大家参考,具体如下:一 为什么出现3DES1、返回柯克霍夫原则2、存在安全问题二 3DES(Triple DES或DESede)好处1、密钥长度增强2、迭代次数提高三 3...
  • 什么是对称加密技术? 对称加密采用了对称密码编码技术,它特点是文件加密和解密使用相同密钥加密 也就是密钥也可以用作解密密钥,这种方法在密码学中叫做...对称加密算法在电子商务交易过程中存在几个问题:...
  • 什么是对称加密技术? 对称加密采用了对称密码编码技术,它特点是文件加密和解密使用相同密钥 也就是密钥也可以用作解密密钥,这种方法在密码学中叫做对称...对称加密算法在电子商务交易过程中存在几个问题...
  • 对称加密算法有AES,DES,3DES,RC4等,加密解密方共用1个密钥,这就导致了很容易被破解,因为密钥在客户端中也存在,无论你如何加密这个字符串,程序跑起来时候这密钥总会在内存里。 一般情况下,我们会使用RSA...
  • Hutool 封装JDK的对称加密AES算法使用

    千次阅读 2020-09-16 23:58:06
    Hutool Hutool 是一个小而全的Java工具类库,提供了很多常用的工具类。... AES封装 遇到一个场景,透出了业务的订单号,该订单号是由...这样就会有数据泄漏问题,因为很容易构造出一个正确的且数据库内存在的这种...
  • 什么是对称加密技术? 对称加密采用了对称密码编码技术,它特点是文件加密和解密使用相同密钥加密 也就是密钥也可以用作解密密钥,这种方法在密码学中叫做...对称加密算法在电子商务交易过程中存在几个问题:...
  • 1、对称加密算法, 加密和解密用是同一个密钥,常见为AES算法。缺点:秘钥才传输过程中可能被截取,存在安全问题, 2、非对称加密算法,常见为RSA算法,它不是像对称机密算法, 双方必须协商一个保密密钥...
  • 文章目录对称加密对称加密的有优缺点密钥分配问题对称加密对称加密的优缺点混合加密 上一章节我们说到解决窃听方法是加密,这里我们来说说加密 ...  对称加密的存在密钥分配问题,A密钥怎么
  • 对称加密的简单介绍

    千次阅读 2020-07-07 15:53:07
    对称加密 对称加密采用了对称密码...对称加密算法在电子商务交易过程中存在几个问题: 1、要求提供一条安全渠道使通讯双方在首次通讯时协商一个共同密钥。直接面对面协商可能是不现实而且难于实施,所以双方可
  • 我也看到过很多人写过.NET中加密算法总结,但我发现个别存在一些问题,很多人喜欢罗列每种加密算法的具体实现,假设我们要求实现AES和Triple DES加密算法,的确可以很多地分别给出它们具体实现。  那我们真有...
  • 摘要算法和加密算法

    2020-10-16 15:51:06
    点击进入我个人博客 文章目录一、加密方式1. 摘要算法2. 对称加密3. 非对称加密4. 数字签名二、秘钥生成1....消息摘要算法存在密钥管理与分发问题,适合于分布式网络上使用 特点 无论输入
  • 加密算法笔记

    2016-12-05 12:10:05
    从古埃及时候就用这种密码学密钥长度越长,加密可靠性就越强密钥是一组特定字符串,是控制明文和密文转换唯一参数,起到“钥匙”作用对称加密算法:对数据进行解密时使用密钥和加密使用密钥是完全...
  • 正确使用AES对称加密

    2019-04-09 08:54:00
    经常我看到项目中有人使用了对称加密算法,用来加密客户或项目传输中的部分数据。但我注意到开发 人员由于不熟悉原理,或者简单复制网上的代码示例,有导致代码存在安全风险。 我经常遇到的问题,有如下: 如使用了...
  • 以下代码侧重于对数据的加密和解密的算法部分,其他部分的问题没处理,仅供参考。   编译器用的是:C-Free 5.0   直接源代码: //RC4算法对数据的加密和解密 #include #include #include #include #...
  • 对称加密、非对称加密、摘要算法区别在哪里? 一、对称加密技术 对称加密特点是加密和解密过程使用相同密钥(也叫做key),也就是说...对称加密算法在电子商务交易过程中存在几个问题: 1、要求提供一条安...
  • 对称和非对称加密 1.什么是对称加密技术? 对称加密采用了对称密码编码技术...对称加密算法在电子商务交易过程中存在几个问题: 1、要求提供一条安全渠道使通讯双方在首次通讯时协商一个共同密钥。直接面对面协商
  • .NET中的加密算法总结

    千次阅读 2011-09-26 14:43:38
    1.1.1 摘要 相信许多人都使用过.NET提供的加密算法,而且在使用过程我们必须了解每种加密...我也看到过很多人写过.NET中加密算法总结,但我发现个别存在一些问题,很多人喜欢罗列每种加密算法的具体实现,假设我们
  • 我也看到过很多人写过.NET中加密算法总结,但我发现个别存在一些问题,很多人喜欢罗列每种加密算法的具体实现,假设我们要求实现AES和Triple DES加密算法,的确可以很多地分别给出它们具体实现。  那我们真...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 140
精华内容 56
关键字:

对称加密算法存在的问题