精华内容
下载资源
问答
  • 对称加密:DES、3DES、DESX、Blowfish、IDEA、RC4、RC5、RC6和AES 非对称加密:RSA、ECC(移动设备用)、Diffie-Hellman、El Gamal、DSA(数字签名用)
  • 典型非对称加密算法RSA(Java)

    千次阅读 2016-11-10 20:01:47
    典型非对称加密算法RSA  DH算法的诞生为后续非对称加密算法奠定了基础,较为典型对称加密算法(如EIGamal、RSA、ECC算法等)都是在DH算法提出后相继提出的,而且其算法核心都源于数学问题。  RSA算法基于大数...

    典型非对称加密算法RSA

        DH算法的诞生为后续非对称加密算法奠定了基础,较为典型的非对称加密算法(如EIGamal、RSA、ECC算法等)都是在DH算法提出后相继提出的,而且其算法核心都源于数学问题。

        RSA算法基于大数因子分解难题,而EIGamal算法和ECC算法则是基于离散对数难题。

    1.简述

        1978年,美国麻省理工学院(MIT)的Ron Rivest、Adi Shamir和Leonand Adleman三位学者提出了一种新的非对称加密算法,这种算法以这三位学者的姓氏开头字母命名,被称为RSA算法。

        RSA算法是唯一被广泛采用并且实现的通用公开加密算法,目前已经成为通用非对称加密算法国际标准。不仅如此,RSA算法既可用于数据加密也可用于数字签名。

        RSA算法把非对称加密算法推向了一个高潮,但它并非没有缺点。相比DES以及其他对称加密算法而言,RSA算法要慢得多。作为加密算法,尤其作为非对称加密算法的典型,针对RSA算法的破解自诞生之日起就从未停止过。

        1999年,RSA-155(512位)被成功分解,历时5个月。

        2002年,RSA-158也被成功因数分解。

        当然,基于大数因子分解数学难题的非对称加密算法仅有RSA算法这一种,但是这不代表RSA算法后继无人。基于离散对数问题的非对称加密算法包括ElGamal和ECC两种算法,他们同样是优秀的非对称加密算法。


    2.模型分析

        以消息传递模型为例,阐述基于RSA算法的消息传递模型是如何工作的。

        RSA算法代表了真正的非对称加密算法,其操作较之DH算法更简单。在构建密钥对方面,RSA算法就相当简单。如图1所示。


        在图1中,以甲乙两方收发信息为例。甲方作为信息的发送方,乙方作为信息的接收方。假设甲乙双方在消息传递之前已将RSA算法作为消息传递的加密算法。为了完成加密消息传递,甲乙双方需要以下操作:

        1)由消息发送的一方构建密钥对,这里由甲方完成。

        2)由消息发送的一方公布公钥至消息接收方,这里由甲方将公钥公布给乙方。

        完成这两步操作后,甲乙双方就可以进行加密消息传递了,如图2和图3所示。


        这里需要注意的:甲方向乙方发送数据时,使用私钥对数据进行加密处理;乙方接收到加密数据后,使用公钥对数据进行解密处理。

        需要注意,在非对称加密算法领域中,对于私钥加密的数据,只能使用公钥解密,简言之“私钥加密,公钥解密”。

        相对于“私钥加密,公钥解密”的实现,RSA算法提供了另一种加密/解密方式“公钥加密,私钥解密”。这使得乙方可以使用公钥加密数据,如图3所示。



        甲方可以向乙方发送加密消息,乙方也同样可以向甲方发送加密消息。在图3中,乙方使用公钥加密信息,甲方使用私钥对加密信息进行解密。这是一种“公钥加密,私钥解密”的加密解密方式。

        

    3.实现

    1)RSA算法实现(RSACoder.java)

    package rsa;
    
    import java.security.Key;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    import javax.crypto.Cipher;
    import javax.security.auth.x500.X500Principal;
    
    import org.bouncycastle.jce.X509KeyUsage;
    import org.bouncycastle.x509.X509Attribute;
    
    public abstract class RSACoder {
    	//非崔晨加密算法
        private static final String KEY_ALGORITHM = "RSA";
        //公钥
        private static final String PUBLIC_KEY = "RSAPublicKey";
        //私钥
        private static final String PRIVATE_KEY = "RSAPrivateKey";
        //密钥长度
        private static final int KEY_SIZE = 1024;
        
        /**
         * 私钥解密
         * @param data 待解密数据
         * @param key 私钥
         * @return byte[] 解密数据
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception{
        	//取得私钥
        	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        	//生成私钥
        	PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        	//对数据解密
        	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        	cipher.init(Cipher.DECRYPT_MODE, privateKey);
        	return cipher.doFinal(data);
        }
        
        /**
         * 公钥解密
         * @param data 待解密数据
         * @param key 公钥
         * @return byte[] 解密数据
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception{
        	//取得公钥
        	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        	//生成公钥
        	PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
        	//对数据解密
        	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        	cipher.init(Cipher.DECRYPT_MODE, publicKey);
        	return cipher.doFinal(data);
        }
        
        /**
         * 私钥加密
         * @param data 待加密数据
         * @param key 私钥
         * @return byte[] 加密数据
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception{
        	//取得私钥
        	PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
        	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        	//生成私钥
        	PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
        	//对数据加密
        	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        	cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        	return cipher.doFinal(data);
        }
        
        /**
         * 公钥加密
         * @param data 待加密数据
         * @param key 公钥
         * @return byte[] 加密数据
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception{
        	//取得公钥
        	X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        	KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        	//生成密钥
        	PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
        	//加密数据
        	Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        	cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        	return cipher.doFinal(data);
        }
        
        /**
         * 取得私钥
         * @param keyMap 私钥Map
         * @return byte[] 私钥
         * @throws Exception
         */
        public static byte[] getPrivateKey(Map<String, Object> keyMap) throws Exception{
        	Key key = (Key)keyMap.get(PRIVATE_KEY);
        	return key.getEncoded();
        }
        
        /**
         * 取得公钥
         * @param keyMap 公钥Map
         * @return byte[] 公钥
         * @throws Exception
         */
        public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception{
        	Key key = (Key)keyMap.get(PUBLIC_KEY);
        	return key.getEncoded();
        }
        
        /**
         * 初始化密钥
         * @return Map 密钥Map
         * @throws Exception
         */
        public static Map<String, Object> initKey() throws Exception{
        	//实例化密钥对生成器
        	KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        	//初始化密钥对生成器
        	keyPairGenerator.initialize(KEY_SIZE);
        	//生成密钥对
        	KeyPair keyPair = keyPairGenerator.generateKeyPair();
        	//公钥
        	RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        	//私钥
        	RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        	//封装密钥
        	Map<String, Object> keyMap = new HashMap<String, Object>(2);
        	keyMap.put(PUBLIC_KEY, publicKey);
        	keyMap.put(PRIVATE_KEY, privateKey);
        	return keyMap;
        }
    }
    

    2)RSA测试(RSATest.java)

    package rsa;
    
    import java.util.Map;
    
    import org.apache.commons.codec.binary.Base64;
    
    
    public class RSATest {
        //公钥
    	private static byte[] publicKey;
    	//私钥
    	private static byte[] privateKey;
    	
    	/**
    	 * 初始化密钥
    	 * @throws Exception
    	 */
    	public static void initKey() throws Exception{
    		//初始化密钥
    		Map<String, Object> keyMap = RSACoder.initKey();
    		publicKey = RSACoder.getPublicKey(keyMap);
    		privateKey = RSACoder.getPrivateKey(keyMap);
    		System.out.println("公钥:\n" + Base64.encodeBase64String(publicKey));
    		System.out.println("私钥:\n" + Base64.encodeBase64String(privateKey));
    	}
    	
    	public static void main(String[] args) throws Exception {
    		// TODO Auto-generated method stub
            initKey();
            System.out.println("\n~~~~~~~~~~~私钥加密,公钥解密~~~~~~~~~~~~~");
            String inputStr = "坚强的意志和决心可以战胜一切困难,执着的信念和无畏的心灵才是最强大的武器。";
            byte[] data1 = inputStr.getBytes();
            System.out.println("原文:\n" + inputStr);
            //私钥加密
            byte[] encodeData1 = RSACoder.encryptByPrivateKey(data1, privateKey);
            System.out.println("加密后:\n" + Base64.encodeBase64String(encodeData1));
            //公钥解密
            byte[] decodeData1 = RSACoder.decryptByPublicKey(encodeData1, publicKey);
            System.out.println("解密后:\n" + new String(decodeData1) + "\n");
            
            initKey();
            System.out.println("\n~~~~~~~~~~~公钥加密,私钥解密~~~~~~~~~~~~~");
            byte[] data2 = inputStr.getBytes();
            System.out.println("原文:\n" + inputStr);
            //公钥加密
            byte[] encodeData2 = RSACoder.encryptByPublicKey(data2, publicKey);
            System.out.println("加密后:\n" + Base64.encodeBase64String(encodeData2));
            //私钥解密
            byte[] decodeData2 = RSACoder.decryptByPrivateKey(encodeData2, privateKey);
            System.out.println("解密后:\n" + new String(decodeData2));
    	}
    
    }
    



    4.运行结果


        


    展开全文
  • 几种对称加密算法:AES,DES,3DES DES是一种分组数据加密技术(先将数据分成固定长度的小数据块,...几种非对称加密算法:RSA,DSA,ECC RSA和DSA的安全性及其它各方面性能都差不多,而ECC较之则有着很多的性能优越,

    1、几种对称性加密算法:AES,DES,3DES

    DES是一种分组数据加密技术(先将数据分成固定长度的小数据块,之后进行加密),速度较快,适用于大量数据加密,而3DES是一种基于DES的加密算法,使用3个不同密匙对同一个分组数据块进行3次加密,如此以使得密文强度更高。

    相较于DES和3DES算法而言,AES算法有着更高的速度和资源使用效率,安全级别也较之更高了,被称为下一代加密标准。
    2、几种非对称性加密算法:RSA,DSA,ECC

    RSA和DSA的安全性及其它各方面性能都差不多,而ECC较之则有着很多的性能优越,包括处理速度,带宽要求,存储空间等等。

    展开全文
  • PKI - 非对称加密算法

    2020-09-23 20:25:51
    非对称加密算法1. 密钥交换算法(DH&ECDH) 密钥管理是对称加密算法系统不容忽视的问题,它成为安全系统中最为薄弱的环节。为了弥补这一弱势,非对称加密算法应运而生。 非对称加密算法源于DH算法(Diffie-...

    密钥管理是对称加密算法系统不容忽视的问题,它成为安全系统中最为薄弱的环节。为了弥补这一弱势,非对称加密算法应运而生。

    非对称加密算法源于DH算法(Diffie-Hellman,密钥交换算法),由W.Diffie和M.Hellman共同提出。该算法为非对称加密算法奠定了基础,堪称非对称加密算法之鼻祖。

    DH算法提出后,国际上相继出现了各种实用性更强的非对称加密算法,其构成主要是基于数学问题的求解,主要分为两类:

    • 基于因子分解难题。RSA算法是最为典型的非对称加密算法,该算法由美国麻省理工学院(MIT)的Ron Rivest、Adi Shamir和Leonard Adleman三位学者提出,并以这三位学者的姓氏开头字母命名,称为RSA算法。RSA算法是当今应用范围最为广泛的非对称加密算法,也是第一个既能用于数据加密也能用于数字签名的算法。

    • 基于离散对数难题。ElGamal算法由TaherElGamal提出,以自己的名字命名。该算法既可用于加密/解密,也可用于数字签名,并为数字签名算法形成标准提供参考。美国的DSS(Digital Signature Standard,数据签名标准)的DSA(Digital Signature Algorithm,数字签名算法)经ElGamal算法演变而来。

    ECC(Elliptical Curve Cryptography,椭圆曲线加密)算法以椭圆曲线理论为基础,在创建密钥时可做到更快、更小,并且更有效。ECC算法通过椭圆曲线方程式的性质产生密钥,而不是采用传统的方法利用大质数的积来产生。

    1. 密钥交换算法(DH&ECDH)

    1.1 DH

    对称加密算法提高数据安全性的同时带来了密钥管理的复杂性。消息收发双方若想发送加密消息,必须事先约定好加密算法并发放密钥。而如何安全的传递密钥,成为对称加密算法的一个棘手问题。密钥交换算法(Diffie-Hellman算法,简称DH算法)成为解决这一问题的金钥匙!

    (甲方)发送方 (乙方)接收方 1. 构建甲方密钥 2. 公布甲方公钥 3. 利用甲方公钥构建乙方密钥 4. 公布乙方公钥 5. 使用甲方私钥、乙方公钥构建本地密钥 6. 使用乙方私钥、甲方公钥构建本地密钥 7. 使用本地密钥对消息加密 8. 发送加密消息 9. 使用本地密钥对消息解密 (甲方)发送方 (乙方)接收方

    代码实现

    public static final String KEY_ALGORITHM = "DH";
    public static final String SECRET_ALGORITHM = "AES";
    public static final int KEY_SIZE = 512;
    public static final String PUBLIC_KEY = "DHPublicKey";
    public static final String PRIVATE_KEY = "DHPrivateKey";
    
    /**
     * 生成甲方密钥对(含公钥、私钥)
     *
     * @return map
     * @throws Exception 异常
     */
    public Map<String, Object> initKey() throws Exception {
        // 初始化密钥对生成器
        final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGenerator.initialize(KEY_SIZE);
    
        // 生成密钥对
        final KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 获取公钥
        final PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        final PrivateKey privateKey = keyPair.getPrivate();
    
        // 构造返回map
        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
    
        return keyMap;
    }
    
    /**
     * 根据甲方公钥生成乙方密钥对(含公钥、私钥)
     *
     * @param key 甲方公钥
     * @return map
     * @throws Exception 异常
     */
    public Map<String, Object> initKey(byte[] key) throws Exception {
        // 解析甲方公钥
        final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
        // 实例化密钥工厂
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 产生甲方公钥
        final PublicKey aPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);
    
        // 由甲方公钥构建乙方密钥
        final DHParameterSpec dhParameterSpec = ((DHPublicKey) aPublicKey).getParams();
        // 初始化密钥对生成器
        final KeyPairGenerator dh = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
        dh.initialize(dhParameterSpec);
        // 生成密钥对
        final KeyPair keyPair = dh.generateKeyPair();
        // 获取公钥
        final PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        final PrivateKey privateKey = keyPair.getPrivate();
    
        // 构造返回map
        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
    
    /**
     * 生成密钥
     * @param publicKey 对方公钥
     * @param privateKey 自己私钥
     * @return 密钥
     * @throws Exception 异常
     */
    public byte[] getSecretKey(byte[] publicKey, byte[] privateKey) throws Exception {
        // 初始化密钥工厂
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
        // 初始化公钥
        final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
        final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
    
        // 初始化私钥
        final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
        final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
    
        // 实例化
        final KeyAgreement keyAgreement = KeyAgreement.getInstance(keyFactory.getAlgorithm());
        keyAgreement.init(priKey);
        keyAgreement.doPhase(pubKey, true);
    
        // 生成本地密钥
        final SecretKey secretKey = keyAgreement.generateSecret(SECRET_ALGORITHM);
        return secretKey.getEncoded();
    }
    
    /**
     * 取得公钥
     *
     * @param keyMap 密钥map
     * @return 公钥
     */
    public byte[] getPublicKey(Map<String, Object> keyMap) {
        final Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
    
    /**
     * 取得私钥
     *
     * @param keyMap 密钥map
     * @return 私钥
     */
    public byte[] getPrivateKey(Map<String, Object> keyMap) {
        final Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    
    /**
     * 数据加密
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return 加密后数据
     */
    public byte[] encrypt(byte[] data, byte[] key) throws Exception {
        // 生成本地密钥
        final SecretKeySpec secretKeySpec = new SecretKeySpec(key, SECRET_ALGORITHM);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(secretKeySpec.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        return cipher.doFinal(data);
    }
    
    /**
     * 数据解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return 解密后数据
     */
    public byte[] decrypt(byte[] data, byte[] key) throws Exception {
        // 生成本地密钥
        final SecretKeySpec secretKeySpec = new SecretKeySpec(key, SECRET_ALGORITHM);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(secretKeySpec.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        return cipher.doFinal(data);
    }
    

    测试用例

    @Test
    public void testDH() throws Exception {
        final Map<String, Object> aKeyMap = initKey();
        final byte[] aPublicKey = getPublicKey(aKeyMap);
        final byte[] aPrivateKey = getPrivateKey(aKeyMap);
        System.out.println("甲方公钥:" + Base64.toBase64String(aPublicKey));
        System.out.println("甲方私钥:" + Base64.toBase64String(aPrivateKey));
    
        final Map<String, Object> bKeyMap = initKey(aPublicKey);
        final byte[] bPublicKey = getPublicKey(bKeyMap);
        final byte[] bPrivateKey = getPrivateKey(bKeyMap);
        System.out.println("乙方公钥:" + Base64.toBase64String(bPublicKey));
        System.out.println("乙方私钥:" + Base64.toBase64String(bPrivateKey));
    
        final byte[] aSecretKey = getSecretKey(bPublicKey, aPrivateKey);
        final byte[] bSecretKey = getSecretKey(aPublicKey, bPrivateKey);
        System.out.println("甲方密钥:" + Base64.toBase64String(aSecretKey));
        System.out.println("乙方密钥:" + Base64.toBase64String(bSecretKey));
    
        final byte[] aEncrypt = encrypt("我是阿汤哥".getBytes(), aSecretKey);
        final byte[] bDecrypt = decrypt(aEncrypt, bSecretKey);
        System.out.println("甲方加密消息:" + Base64.toBase64String(aEncrypt));
        System.out.println("乙方解密消息:" + Base64.toBase64String(bDecrypt));
    
        final byte[] bEncrypt = encrypt("Hello, 阿汤哥".getBytes(), bSecretKey);
        final byte[] aDecrypt = decrypt(bEncrypt, aSecretKey);
        System.out.println("乙方加密消息:" + Base64.toBase64String(bEncrypt));
        System.out.println("甲方解密消息:" + Base64.toBase64String(aDecrypt));
    }
    

    使用jdk8执行本用例时如果报错

    java.security.NoSuchAlgorithmException: Unsupported secret key algorithm: AES
    
    	at com.sun.crypto.provider.DHKeyAgreement.engineGenerateSecret(DHKeyAgreement.java:387)
    	at javax.crypto.KeyAgreement.generateSecret(KeyAgreement.java:648)
    	at com.jd.eps.eis.product.core.config.DHTest.getSecretKey(DHTest.java:110)
    	at com.jd.eps.eis.product.core.config.DHTest.testDH(DHTest.java:183)
    

    可以通过增加vm参数 -Djdk.crypto.KeyAgreement.legacyKDF=true 解决。

    执行结果

    甲方公钥:MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAMCeFF4M4gFXNabyak7DplZnTVPJCNpw9eOao4BWNrdu8ptUiTg4kwmP8bxjot873vQ7QDg4cPyTFJGZ/c3HApE=
    甲方私钥:MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEA1f2vYbDfzWpVlX8ib4ftWD5q24Mzh74C0L+ze8ienkfwv41dErOl0HqZOmmf18HN
    乙方公钥:MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAJ3BzkiX8n6RurBasjqLYwCbewwX0ZkWykCzyQj6y/4uBgNX0m+0bgPX1emxlFt/N3ueC8803OhNcprcHRxschY=
    乙方私钥:MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqi55vmMEF5pfS4//fvfqELLlo817cCRlRMOZ+sQ9HLtroIJ16x7RWusDpK75dqxA
    甲方密钥:sSVOKIBcVtQ5h806csVXzmkPZWUhC75Xp9glwAjFWhY=
    乙方密钥:sSVOKIBcVtQ5h806csVXzmkPZWUhC75Xp9glwAjFWhY=
    甲方加密消息:DPftIVbpAGj7dkF73QB4zw==
    乙方解密消息:我是阿汤哥
    乙方加密消息:FTZnyPN+ZAzdqU4vEKjkMCo6U0TLlKPDyL3zoBSGvvQ=
    甲方解密消息:Hello, 阿汤哥
    

    1.2 ECDH

    JDK8没有ECDH的实现,需要添加Provider。

    Security.addProvider(new BouncyCastleProvider());
    

    根据甲方公钥生成乙方密钥对时需对ParameterSpec进行调整。

    /**
     * 根据甲方公钥生成乙方密钥对(含公钥、私钥)
     *
     * @param key 甲方公钥
     * @return map
     * @throws Exception 异常
     */
    public Map<String, Object> initKey(byte[] key) throws Exception {
        // 解析甲方公钥
        final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(key);
        // 实例化密钥工厂
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 产生甲方公钥
        final PublicKey aPublicKey = keyFactory.generatePublic(x509EncodedKeySpec);
    
        // 由甲方公钥构建乙方密钥
        final ECParameterSpec ecParameterSpec = ((ECPublicKey) aPublicKey).getParams();
        // 初始化密钥对生成器
        final KeyPairGenerator dh = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
        dh.initialize(ecParameterSpec);
        // 生成密钥对
        final KeyPair keyPair = dh.generateKeyPair();
        // 获取公钥
        final PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        final PrivateKey privateKey = keyPair.getPrivate();
    
        // 构造返回map
        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }
    

    2. 典型非对称加密算法 - RSA

    甲方(发送者) 乙方(接收者) 1. 构建密钥对 2. 发布公钥 3. 使用私钥加密数据 4. 发送加密数据 5. 使用甲方公钥解密数据 6. 使用甲方公钥加密数据 7. 发送加密数据 8. 使用私钥解密数据 甲方(发送者) 乙方(接收者)

    代码实现

    public static final String KEY_ALGORITHM = "RSA";
    public static final int KEY_SIZE = 512;
    public static final String PUBLIC_KEY = "DHPublicKey";
    public static final String PRIVATE_KEY = "DHPrivateKey";
    
    /**
     * 生成甲方密钥对(含公钥、私钥)
     *
     * @return map
     * @throws Exception 异常
     */
    public Map<String, Object> initKey() throws Exception {
        // 初始化密钥对生成器
        final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGenerator.initialize(KEY_SIZE);
    
        // 生成密钥对
        final KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 获取公钥
        final PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        final PrivateKey privateKey = keyPair.getPrivate();
    
        // 构造返回map
        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
    
        return keyMap;
    }
    
    /**
     * 取得公钥
     *
     * @param keyMap 密钥map
     * @return 公钥
     */
    public byte[] getPublicKey(Map<String, Object> keyMap) {
        final Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
    
    /**
     * 取得私钥
     *
     * @param keyMap 密钥map
     * @return 私钥
     */
    public byte[] getPrivateKey(Map<String, Object> keyMap) {
        final Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    
    /**
     * 使用私钥加密数据
     *
     * @param data       待加密数据
     * @param privateKey 私钥
     * @return 加密后数据
     */
    public byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
        // 获取私钥
        final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私钥
        final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, priKey);
        return cipher.doFinal(data);
    }
    
    /**
     * 使用公钥解密数据
     *
     * @param data      待解密数据
     * @param publicKey 公钥
     * @return 解密后数据
     */
    public byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
        // 获取公钥
        final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成公钥
        final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }
    
    /**
     * 使用公钥加密数据
     *
     * @param data      待解密数据
     * @param publicKey 公钥
     * @return 解密后数据
     */
    public byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
        // 获取公钥
        final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成公钥
        final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }
    
    /**
     * 使用私钥解密数据
     *
     * @param data       待加密数据
     * @param privateKey 私钥
     * @return 加密后数据
     */
    public byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
        // 获取私钥
        final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私钥
        final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        return cipher.doFinal(data);
    }
    
    @Test
    public void testRSA() throws Exception {
        Security.addProvider(new BouncyCastleProvider());
    
        final Map<String, Object> aKeyMap = initKey();
        final byte[] aPublicKey = getPublicKey(aKeyMap);
        final byte[] aPrivateKey = getPrivateKey(aKeyMap);
        System.out.println("甲方公钥:" + Base64.toBase64String(aPublicKey));
        System.out.println("甲方私钥:" + Base64.toBase64String(aPrivateKey));
    
    
        final byte[] aEncrypt = encryptByPrivateKey("我是阿汤哥".getBytes(), aPrivateKey);
        final byte[] bDecrypt = decryptByPublicKey(aEncrypt, aPublicKey);
        System.out.println("甲方:使用甲方私钥加密消息:" + Base64.toBase64String(aEncrypt));
        System.out.println("乙方:使用甲方公钥解密消息:" + new String(bDecrypt));
    
        final byte[] bEncrypt = encryptByPublicKey("Hello, 阿汤哥".getBytes(), aPublicKey);
        final byte[] aDecrypt = decryptByPrivateKey(bEncrypt, aPrivateKey);
        System.out.println("乙方:使用甲方公钥加密消息:" + Base64.toBase64String(bEncrypt));
        System.out.println("甲方:使用甲方私钥解密消息:" + new String(aDecrypt));
    }
    

    执行结果

    甲方公钥:MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJ7vEoMQFnSZq8tIKydTxeZQZbg3EzZ+uoqMB6xYUz0bJKTLBE2VdT8SKmhCFjyBLzRla8bCl5EtLB/S3F/isD0CAwEAAQ==
    甲方私钥:MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAnu8SgxAWdJmry0grJ1PF5lBluDcTNn66iowHrFhTPRskpMsETZV1PxIqaEIWPIEvNGVrxsKXkS0sH9LcX+KwPQIDAQABAkAePbMyCP+c1BiiJ2s+omwHdMjGEoSvW9G2xwo2ut+rwo+UiKX/OXtjggNL32sOG/VBpmwQnCzhHXlM3Uf/AyLBAiEA0j02vlbqrkb4eLLTX/K1ZXk05xFMaxjCfqIdv9VwqykCIQDBhxD/jP48lN/I/cNQjg4710e46gL5U3TvDfmpXZYS9QIgYAHkRfebJAr03OmM7XwAql43cm3L3/xmlT2jKD9oPEECIBAgRh1VTVYU/bTM2Hqc67i2zqYs8cR+3M6StowTXU8FAiAp+LnIyULp1obJN9ZnLRv5RldROa9Evj94cfDq3gu+QQ==
    甲方:使用甲方私钥加密消息:lK3A3bNyxV1xc34st8fOtIy5vyjTL1zm7wbU9v5mV21t0hxf1ZLTdvN5+vZPSylF3th0c0KqSdGNLpaazvEYSg==
    乙方:使用甲方公钥解密消息:我是阿汤哥
    乙方:使用甲方公钥加密消息:msiUhALltZYWQdpDWpp6X4wmDCR3ZVGw4d3AqYBnnwDloNDBivpBhT4LgWseX7x74GpgKFA1g/mpsKCIoXqOiw==
    甲方:使用甲方私钥解密消息:Hello, 阿汤哥
    

    3. 常用非对称加密算法 - ElGamal

    甲方(发送者) 乙方(接收者) 1. 构建密钥对 2. 发布公钥 3. 使用乙方公钥加密数据 4. 发送加密数据 5. 使用私钥解密数据 甲方(发送者) 乙方(接收者)

    代码实现

    public static final String KEY_ALGORITHM = "ElGamal";
    public static final int KEY_SIZE = 256;
    public static final String PUBLIC_KEY = "ElGamalPublicKey";
    public static final String PRIVATE_KEY = "ElGamalPrivateKey";
    
    /**
     * 生成甲方密钥对(含公钥、私钥)
     *
     * @return map
     * @throws Exception 异常
     */
    public Map<String, Object> initKey() throws Exception {
        // 加入BouncyCastleProvider支持
        Security.addProvider(new BouncyCastleProvider());
        // 实例化算法参数生成器
        final AlgorithmParameterGenerator apg = AlgorithmParameterGenerator.getInstance(KEY_ALGORITHM);
        // 初始化算法生成器
        apg.init(KEY_SIZE);
        // 生成算法参数
        final AlgorithmParameters parameters = apg.generateParameters();
        // 构建参数材料
        final DHParameterSpec dhParameterSpec = parameters.getParameterSpec(DHParameterSpec.class);
        // 实例化密钥对生成器
        final KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGenerator.initialize(dhParameterSpec, new SecureRandom());
    
        // 生成密钥对
        final KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 获取公钥
        final PublicKey publicKey = keyPair.getPublic();
        // 获取私钥
        final PrivateKey privateKey = keyPair.getPrivate();
    
        // 构造返回map
        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
    
        return keyMap;
    }
    
    /**
     * 取得公钥
     *
     * @param keyMap 密钥map
     * @return 公钥
     */
    public byte[] getPublicKey(Map<String, Object> keyMap) {
        final Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
    
    /**
     * 取得私钥
     *
     * @param keyMap 密钥map
     * @return 私钥
     */
    public byte[] getPrivateKey(Map<String, Object> keyMap) {
        final Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    
    /**
     * 使用公钥加密数据
     *
     * @param data      待解密数据
     * @param publicKey 公钥
     * @return 解密后数据
     */
    public byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
        Security.addProvider(new BouncyCastleProvider());
        // 获取公钥
        final X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKey);
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成公钥
        final PublicKey pubKey = keyFactory.generatePublic(x509EncodedKeySpec);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }
    
    /**
     * 使用私钥解密数据
     *
     * @param data       待加密数据
     * @param privateKey 私钥
     * @return 加密后数据
     */
    public byte[] decryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
        Security.addProvider(new BouncyCastleProvider());
        // 获取私钥
        final PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKey);
        final KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        // 生成私钥
        final PrivateKey priKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 数据加密
        final Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, priKey);
        return cipher.doFinal(data);
    }
    
    @Test
    public void testRSA() throws Exception {
        Security.addProvider(new BouncyCastleProvider());
    
        final Map<String, Object> bKeyMap = initKey();
        final byte[] bPublicKey = getPublicKey(bKeyMap);
        final byte[] bPrivateKey = getPrivateKey(bKeyMap);
        System.out.println("乙方公钥:" + Base64.toBase64String(bPublicKey));
        System.out.println("乙方私钥:" + Base64.toBase64String(bPrivateKey));
    
        final byte[] aEncrypt = encryptByPublicKey("我是阿汤哥".getBytes(), bPublicKey);
        final byte[] bDecrypt = decryptByPrivateKey(aEncrypt, bPrivateKey);
        System.out.println("甲方:使用乙方公钥加密消息:" + Base64.toBase64String(aEncrypt));
        System.out.println("乙方:使用乙方私钥解密消息:" + new String(bDecrypt));
    }
    

    执行结果

    乙方公钥:MHYwTwYGKw4HAgEBMEUCIQD3Tow0iMrSnqcab/qk3sixGNZsFqerw5TZS8AthdG9/wIgVwGItAIOERVrOUQuvYUf4iBgNedVcIVEMpmCAAF67GsDIwACICuSrF+jA6g2XGfFjtP8zmZWA0LstwQQgsMBB6AYuA1/
    乙方私钥:MHgCAQAwTwYGKw4HAgEBMEUCIQD3Tow0iMrSnqcab/qk3sixGNZsFqerw5TZS8AthdG9/wIgVwGItAIOERVrOUQuvYUf4iBgNedVcIVEMpmCAAF67GsEIgIgS99qTF3QgAjIKNcpPaA5jnTSp6AUOqb1XhOGGtr75iw=
    甲方:使用乙方公钥加密消息:3sdh+pOViDQWU8aDO/LC1SnK427qrFc8PHrMVyE+k7MbL7tQHbq+5I7MZ0vz7WAc6ysAvVZU9pg8YcQvoYWoEw==
    乙方:使用乙方私钥解密消息:我是阿汤哥
    
    展开全文
  • 对称加密算法非对称加密算法

    千次阅读 2019-03-17 15:59:04
    有一种加密算法叫做对称加密对称加密是以前比较常见的一种加密方式。所谓对称加密的意思是说假如有一个人A,他想把一个信号m传递给B,他不能直接将这个信息传递给B,否则会有人可能会窃听。于是通过一些算法,...

            比如说我们去银行存钱取钱,用到密码,密码是基于数学的,我们来讨论下关于密码学的问题:
            有一种加密算法叫做对称加密,对称加密是以前比较常见的一种加密方式。所谓对称加密的意思是说假如有一个人A,他想把一个信号m传递给B,他不能直接将这个信息传递给B,否则会有人可能会窃听。于是通过一些算法,比如通过加一个数字e变成了一个新的数字C,他把C传递给B,B接收到C之后再减去那个e就会得到原来的数字m。


           比如想要传递2  e=1 2+1=3    B接收到3之后3-1=2    ,于是我们就知道m了
    在这个过程中,我们将

    • m称为明文,就是我们希望表达的含义
    • C我们称之为密文,就是我们可以公开传递的一个信息
    • e就是密钥,密钥是要保密的,我们不可以告诉其他人

            算法其实可以比较复杂,不一定是加一个数字,他可能是m乘以e得到一个数字得到C,我们得到C之后可以除以e。也可以是m的e次方,得到一个数字,我们再开e次根号就可以了。算法可以非常复杂,但是再复杂也存在被窃听的可能,因为可以穷举,比如他一次又一次的尝试以前的算法,他还可以通过数字的频率,比如在英文的26个字母中,在一段话中出现的频率不一样,他只要截取到足够多的密文,一次又一次的尝试,他就可以把你的密钥给试出来,所以密钥是不保险的。

            于是人们就想能不能我们发一段文字之后就换一个密钥。再发一段文字,我再换一个密钥,这样别人就不知道我说的是什么了。但是问题是密钥的分发又成为了一个问题,你怎么才可以把这个e安全的传给B,你派一个人去传这样 的效率很低,你打电话给B,B有可能会被监听。所以密钥分发是一件非常麻烦的事情,那么现在的量子保密通信就可以实现密钥分发的保密性。

            那么除了这种对称加密以外,现在比较流行的一种算法叫做非对称加密。A想把一个信息m传递给B。首先B先干这么一件事情。B生成两个有相互关系的数字,这两个有相关性的数字,一个叫做e,一个叫做d。那么这个e就叫做公钥,公共的钥匙,而这个d就叫做私钥,私人的钥匙。然后B先把这个e公钥传递给A,可以通过公开的方式传递,这样的话我不怕你窃听。我告诉你公钥是什么,然后这个A通过这种公钥e的某一个算法得到一个密文C。然后再通过公开的方式将这个密文传递给B,那么这个不对称性就体现在这个地方了。通过密文求解原文的过程,不是减去e,而是要减去d,通过减去一个d我们就可以得到明文m。也就是说,这个d和e是有一定的关系的,我经过加密的时候,我是用的e对数字进行加密,我解密的时候呢,需要用到d数字进行解密
            我传递公钥的过程的我不怕你窃听。因为就算是你窃听了,你也不会知道这个密钥是什么。所以你窃听了我的公钥和密文之后,你依然无法得到明文,这个就是非对称加密的方式。

            那么非对称加密是基于什么样的一个数学原理呢?我们接下来的时间会来介绍一种典型的非对称加密方式,叫做RSA加密算法。敬请期待!

            撒花✿✿ヽ(°▽°)ノ✿!!!

     

    展开全文
  • 介绍典型非对称加密算法——RSA

    千次阅读 2014-08-21 20:16:10
     接下来我们介绍典型非对称加密算法——RSA RSA  这种算法1978年就出现了,它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作,也很流行。算法的名字以发明者的名字命名:Ron Rivest, ...
  • 然而密码技术认为,「保密」信息总有一天会被扒出来,所以加密算法不应该依靠「保密」来保证机密性,而应该做到:即便知道了加密算法,依然无计可施。说的魔幻一点就是,告诉你我的密码,你依然不知道我的...
  • RSA(典型非对称加密算法) RSACoder工具类 RSACoderTest 参考资料 本系列其他文章 RSA(典型非对称加密算法) 之前介绍了DH算法,现在我们来介绍RSA算法。 在公开密钥密码体制中,加密密钥(即公开密钥)PK...
  • 非对称加密算法应用

    2021-01-03 18:48:03
    非对称加密算法(签名算法)应用场景 算法名称 全名 应用 方程式 pyhon开源实现 dsa Digital Signature Algorithm,数字签名算法 openssh(linux上ssh命令及其工具) ECDSA Elliptic Curve Digital Signature Algorith ...
  • DES算法为密码体制中的对称密码体制,是一个分组加密算法典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。 这里以Java代码实现DES算法。
  • 典型非对称加密算法RSA算法相比,ElGamal算法则被称为常用非对称加密算法。 ElGamal既可用于加密,又可用于数字签名,是除RSA算法外最具代表性的公钥加密算法之一。 ElGamal算法就有较好的安全性,被广发应用。...
  • 前篇文章介绍如何使用对称加密算法来对文件进行加密和解密操作,这篇文章以RSA为例介绍非对称加密算法的使用方式。
  • 加密目前已经成为计算机安全研究的主要方向,一个密码系统的安全性主要在于密钥的保密性,而不是算法的保密性。 加密系统至少要包括如下四个部分 1 未加密的报文,也叫明文:用M(消息)或P(明文)表示,可以是...
  • 文章目录一、HTTPS原理以及解析二、对称加密非对称加密三、总结 一、HTTPS原理以及解析 HTTPS(全称:Hypertext Transfer Protocol over Secure Socket Layer),是以安全为目标的HTTP通道,简单讲是HTTP的安全版...
  • [b]一、什么是非对称加密算法[/b] 加密和解密所用的密钥是不一样的,所以叫“对称”。 非对称加密算法的这两个密钥,一个称为公钥,一个称为...RSA就是典型非对称加密算法。 关于RSA算法的解释,最经典的...
  • DES是1977年美国联邦信息处理标准(FIPS)中所采用的一种对称密码(FIPS46.3)。DES一直以来被美国以及其他国家的政府和银行等广泛使用。然而,随着计算机的进步,现在DES已经能够被暴力破解,强度大不如前了 ...
  • 对称加密算法的基石,具有学习价值 密钥长度56(JDK)、56/64(BC) 2、DESede(三重DES) 早于AES出现来替代DES 计算密钥时间太长、加密效率不高,所以也基本上不用 密钥长度112/168(JDK)、128/192(BC) 3、...
  • 最全加密算法对称加密非对称加密

    万次阅读 多人点赞 2016-08-27 10:27:30
    常见加密算法 : DES(Data Encryption Standard):数据加密标准,速度较快,适用于加密大量数据的场合;  3DES(Triple DES):是基于DES,对一块数据用三个不同的密钥进行三次加密,强度更高; RC2和 RC4:用变...
  • 加密分为两大类:对称加密非对称加密,两类加密算法各有优点,在不同的场景使用不同的算法。 对称加密 加密方将原始数据和加密密钥一起经过特殊加密算法处理后,生成密文结果,解密方使用相同的秘钥及相同加密...
  • Java加密技术 接下来我们介绍典型非对称加密算法RSA RSA 这种算法1978年就出现了它是第一个既能用于数据加密也能用于数字签名的算法它易于理解和操作也很流行算法的名字以发明者的名字命名Ron Rivest, AdiShamir ...
  • DES(Data Encryption Standard)是一种单一密钥对称加解密算法。通信主体之间只有一个密钥,该密钥不对第三方公开。但由于密钥长度较短,导致安全性不高。DES算法的入口参数有三个:Key、Data、Mode。其中Key为8个...
  • 而是一种建立在应用层和传输层基础上的安全外壳协议,熟悉Linux的朋友经常使用到一 个SSH Secure Shell Cilent的工具,本文也是基于此工具加密原理的学习,在SSH的加密原理中,使用到了RSA非对称加密算法,本文也...
  •  了解数字签名前先了解一下sha-1摘要,rsa加密算法。然后,再了解数字签名。 SHA-1  SHA-1(secure hash Algorithm )是一种数据加密算法。该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段...
  • 常用的对称加密算法

    千次阅读 2019-10-26 17:20:38
    需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。 所谓对称,就是采用这种加密方法的双方使用方式用同样的密钥进行加密和...
  • 目录 一、对称加密(Symmetric Cryptography) 优缺点 二、对称加密(asymmetric Cryptography) ...非对称加密算法使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢,解决加密解密慢的...
  • 对称加密算法 定义 对称加密算法是指加密密钥和解密密钥相同的密码算法,又称秘密密钥算法或单密钥算法。 优势以及劣势 优势 算法公开、计算量小、加密速度快、加密效率高。 劣势 交易双方都使用同样钥匙,安全...
  • 基本概念: 未加密消息在密码学中被称为明文 伪装消息以隐藏消息的过程称为加密 ...优点:算法公开、计算量小、加密速度快、加密效率高。 缺点: (1)交易双方都使用同样钥匙,安全性得不到保证。 (...
  • 是计算机广泛使用的杂凑算法之一(又译摘要算法、哈希算法),主流编程语言普遍已有MD5实现。将数据(如汉字)运算为另一固定长度值. MD5算法具有以下特点: 1、压缩性:任意长度的数据,算出的MD5值长度都是固定...
  • 常见对称加密算法

    千次阅读 2019-04-10 09:13:49
    目前在后台架构中,常用的有对称加密算法和飞对称加密算法。 + 加密应用场景:敏感信息加密,比如,证件号码,银行卡账号,邮件信息,聊天记录cookie信息,私钥保护等等。 常见的对称加密算法有: 常用算法介绍 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,104
精华内容 5,241
关键字:

典型的非对称加密算法