zoukankan      html  css  js  c++  java
  • Java加密技术(五)——非对称加密算法的由来DH

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

    流程分析:

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





    通过java代码实现如下:Coder类见 Java加密技术(一)
    Java代码  收藏代码
    import java.security.Key; 
    import java.security.KeyFactory; 
    import java.security.KeyPair; 
    import java.security.KeyPairGenerator; 
    import java.security.PublicKey; 
    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.KeyAgreement; 
    import javax.crypto.SecretKey; 
    import javax.crypto.interfaces.DHPrivateKey; 
    import javax.crypto.interfaces.DHPublicKey; 
    import javax.crypto.spec.DHParameterSpec; 
     
    /**
    * DH安全编码组件

    * @author 梁栋
    * @version 1.0
    * @since 1.0
    */ 
    public abstract class DHCoder extends Coder { 
        public static final String ALGORITHM = "DH"; 
     
        /**
         * 默认密钥字节数
         * 
         * <pre>
         * DH
         * Default Keysize 1024  
         * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
         * </pre>
         */ 
        private static final int KEY_SIZE = 1024; 
     
        /**
         * DH加密下需要一种对称加密算法对数据加密,这里我们使用DES,也可以使用其他对称加密算法。
         */ 
        public static final String SECRET_ALGORITHM = "DES"; 
        private static final String PUBLIC_KEY = "DHPublicKey"; 
        private static final String PRIVATE_KEY = "DHPrivateKey"; 
     
        /**
         * 初始化甲方密钥
         * 
         * @return
         * @throws Exception
         */ 
        public static Map<String, Object> initKey() throws Exception { 
            KeyPairGenerator keyPairGenerator = KeyPairGenerator 
                    .getInstance(ALGORITHM); 
            keyPairGenerator.initialize(KEY_SIZE); 
     
            KeyPair keyPair = keyPairGenerator.generateKeyPair(); 
     
            // 甲方公钥 
            DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic(); 
     
            // 甲方私钥 
            DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate(); 
     
            Map<String, Object> keyMap = new HashMap<String, Object>(2); 
     
            keyMap.put(PUBLIC_KEY, publicKey); 
            keyMap.put(PRIVATE_KEY, privateKey); 
            return keyMap; 
        } 
     
        /**
         * 初始化乙方密钥
         * 
         * @param key
         *            甲方公钥
         * @return
         * @throws Exception
         */ 
        public static Map<String, Object> initKey(String key) throws Exception { 
            // 解析甲方公钥 
            byte[] keyBytes = decryptBASE64(key); 
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes); 
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); 
            PublicKey pubKey = keyFactory.generatePublic(x509KeySpec); 
     
            // 由甲方公钥构建乙方密钥 
            DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams(); 
     
            KeyPairGenerator keyPairGenerator = KeyPairGenerator 
                    .getInstance(keyFactory.getAlgorithm()); 
            keyPairGenerator.initialize(dhParamSpec); 
     
            KeyPair keyPair = keyPairGenerator.generateKeyPair(); 
     
            // 乙方公钥 
            DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic(); 
     
            // 乙方私钥 
            DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate(); 
     
            Map<String, Object> keyMap = new HashMap<String, Object>(2); 
     
            keyMap.put(PUBLIC_KEY, publicKey); 
            keyMap.put(PRIVATE_KEY, privateKey); 
     
            return keyMap; 
        } 
     
        /**
         * 加密<br>
         * 
         * @param data
         *            待加密数据
         * @param publicKey
         *            甲方公钥
         * @param privateKey
         *            乙方私钥
         * @return
         * @throws Exception
         */ 
        public static byte[] encrypt(byte[] data, String publicKey, 
                String privateKey) throws Exception { 
     
            // 生成本地密钥 
            SecretKey secretKey = getSecretKey(publicKey, privateKey); 
     
            // 数据加密 
            Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm()); 
            cipher.init(Cipher.ENCRYPT_MODE, secretKey); 
     
            return cipher.doFinal(data); 
        } 
     
        /**
         * 解密<br>
         * 
         * @param data
         *            待解密数据
         * @param publicKey
         *            乙方公钥
         * @param privateKey
         *            乙方私钥
         * @return
         * @throws Exception
         */ 
        public static byte[] decrypt(byte[] data, String publicKey, 
                String privateKey) throws Exception { 
     
            // 生成本地密钥 
            SecretKey secretKey = getSecretKey(publicKey, privateKey); 
            // 数据解密 
            Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm()); 
            cipher.init(Cipher.DECRYPT_MODE, secretKey); 
     
            return cipher.doFinal(data); 
        } 
     
        /**
         * 构建密钥
         * 
         * @param publicKey
         *            公钥
         * @param privateKey
         *            私钥
         * @return
         * @throws Exception
         */ 
        private static SecretKey getSecretKey(String publicKey, String privateKey) 
                throws Exception { 
            // 初始化公钥 
            byte[] pubKeyBytes = decryptBASE64(publicKey); 
     
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM); 
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes); 
            PublicKey pubKey = keyFactory.generatePublic(x509KeySpec); 
     
            // 初始化私钥 
            byte[] priKeyBytes = decryptBASE64(privateKey); 
     
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes); 
            Key priKey = keyFactory.generatePrivate(pkcs8KeySpec); 
     
            KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory 
                    .getAlgorithm()); 
            keyAgree.init(priKey); 
            keyAgree.doPhase(pubKey, true); 
     
            // 生成本地密钥 
            SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM); 
     
            return secretKey; 
        } 
     
        /**
         * 取得私钥
         * 
         * @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()); 
        } 



    再给出一个测试类:
    Java代码  收藏代码
    import static org.junit.Assert.*; 
     
    import java.util.Map; 
     
    import org.junit.Test; 
     
    /**

    * @author 梁栋
    * @version 1.0
    * @since 1.0
    */ 
    public class DHCoderTest { 
     
        @Test 
        public void test() throws Exception { 
            // 生成甲方密钥对儿 
            Map<String, Object> aKeyMap = DHCoder.initKey(); 
            String aPublicKey = DHCoder.getPublicKey(aKeyMap); 
            String aPrivateKey = DHCoder.getPrivateKey(aKeyMap); 
     
            System.err.println("甲方公钥: " + aPublicKey); 
            System.err.println("甲方私钥: " + aPrivateKey); 
             
            // 由甲方公钥产生本地密钥对儿 
            Map<String, Object> bKeyMap = DHCoder.initKey(aPublicKey); 
            String bPublicKey = DHCoder.getPublicKey(bKeyMap); 
            String bPrivateKey = DHCoder.getPrivateKey(bKeyMap); 
             
            System.err.println("乙方公钥: " + bPublicKey); 
            System.err.println("乙方私钥: " + bPrivateKey); 
             
            String aInput = "abc "; 
            System.err.println("原文: " + aInput); 
     
            // 由甲方公钥,乙方私钥构建密文 
            byte[] aCode = DHCoder.encrypt(aInput.getBytes(), aPublicKey, 
                    bPrivateKey); 
     
            // 由乙方公钥,甲方私钥解密 
            byte[] aDecode = DHCoder.decrypt(aCode, bPublicKey, aPrivateKey); 
            String aOutput = (new String(aDecode)); 
     
            System.err.println("解密: " + aOutput); 
     
            assertEquals(aInput, aOutput); 
     
            System.err.println(" ===============反过来加密解密================== "); 
            String bInput = "def "; 
            System.err.println("原文: " + bInput); 
     
            // 由乙方公钥,甲方私钥构建密文 
            byte[] bCode = DHCoder.encrypt(bInput.getBytes(), bPublicKey, 
                    aPrivateKey); 
     
            // 由甲方公钥,乙方私钥解密 
            byte[] bDecode = DHCoder.decrypt(bCode, aPublicKey, bPrivateKey); 
            String bOutput = (new String(bDecode)); 
     
            System.err.println("解密: " + bOutput); 
     
            assertEquals(bInput, bOutput); 
        } 
     



    控制台输出:
    Console代码  收藏代码
    甲方公钥: 
    MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz 
    W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG 
    kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko 
    Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ== 
     
    甲方私钥: 
    MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX 
    rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD 
    TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR 
    eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos= 
     
    乙方公钥: 
    MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz 
    W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG 
    kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr 
    dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ== 
     
    乙方私钥: 
    MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX 
    rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD 
    TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp 
    2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd 
     
    原文: abc  
    解密: abc  
    ===============反过来加密解密==================  
    原文: def  
    解密: def  


    如我所言,甲乙双方在获得对方公钥后可以对发送给对方的数据加密,同时也能对接收到的数据解密,达到了数据安全通信的目的!
  • 相关阅读:
    Laravel 初始化
    ant design pro 左上角 logo 修改
    请求到服务端后是怎么处理的
    Websocket 知识点
    王道数据结构 (7) KMP 算法
    王道数据结构 (6) 简单的模式匹配算法
    王道数据结构 (4) 单链表 删除节点
    王道数据结构 (3) 单链表 插入节点
    王道数据结构 (2) 单链表 尾插法
    王道数据结构 (1) 单链表 头插法
  • 原文地址:https://www.cnblogs.com/iamconan/p/7383468.html
Copyright © 2011-2022 走看看