Java非对称加密(DH算法）

古城微笑少年丶 2022-07-16 10:42 215阅读 0赞

方法类：

import javax.crypto.KeyAgreement;
    import javax.crypto.SecretKey;
    import javax.crypto.interfaces.DHPrivateKey;
    import javax.crypto.interfaces.DHPublicKey;
    import javax.crypto.spec.DHParameterSpec;
    import java.io.OutputStream;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Created by cuboo on 2016/10/15.
     */
    public class DH_RSA {
        public static final String PUBLIC_KEY = "DHPublicKey";
        public static final String PRIVATE_KEY = "DHPrivateKey";
        /*
         *步骤1生成A的公钥和私钥 keyType = "DH" keySize = 1024 512 - 2048(64的整数倍)
         */
        public static Map<String,Object> GenerateKeyPairOfA(String keyType, int keySize) throws Exception {
            KeyPairGenerator pairGenerator = KeyPairGenerator.getInstance(keyType);
            pairGenerator.initialize(keySize);
            //生成秘钥对
            KeyPair keyPair = pairGenerator.generateKeyPair();
            //获得公钥和私钥
            DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
            DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
            Map<String,Object> map = new HashMap<String,Object>();
            map.put(PUBLIC_KEY,publicKey);
            map.put(PRIVATE_KEY,privateKey);
            return  map;
        }
    
        /*
         *B根据A的公钥生成自己是密钥对公钥和私钥
         */
        public static Map<String,Object> GenerateKeyPairOfB(String keyType,byte[] Akey) throws Exception {
            //将A的key字节数组转成公钥
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Akey);
            KeyFactory factory = KeyFactory.getInstance(keyType);
            //产生A的公钥
            DHPublicKey key = (DHPublicKey) factory.generatePublic(keySpec);
            //得到A公钥的参数
            DHParameterSpec paraSpec = key.getParams();
            /*
             *获得B的密钥对
             */
            KeyPairGenerator pairGenerator = KeyPairGenerator.getInstance(keyType);
            pairGenerator.initialize(paraSpec);
            //生成秘钥对
            KeyPair keyPair = pairGenerator.generateKeyPair();
            //获得公钥和私钥
            DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
            DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
            Map<String,Object> map = new HashMap<String,Object>();
            map.put(PUBLIC_KEY,publicKey);
            map.put(PRIVATE_KEY,privateKey);
            return  map;
        }
    
        /*
         *生成本地秘钥 keyType = "DH" keyType1 = "EDS/EDSede/AES"
         * A自己的私钥和B的公钥或 B自己的私钥和A的公钥
         */
        public static byte[] GenerateLocalKey(String keyType,String keyType1,byte[] ApublicKey,byte[] BprivateKey) throws Exception {
            KeyFactory factory = KeyFactory.getInstance(keyType);
            //将A的key字节数组转成公钥
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(ApublicKey);
            DHPublicKey publickey = (DHPublicKey) factory.generatePublic(keySpec);
            //将B的key字节数组转成私钥
            PKCS8EncodedKeySpec keySpec1 = new PKCS8EncodedKeySpec(BprivateKey);
            DHPrivateKey privatekey = (DHPrivateKey) factory.generatePrivate(keySpec1);
    
            KeyAgreement agreement = KeyAgreement.getInstance(keyType);
            //A自己的私钥
            agreement.init(privatekey);
            //对方B的公钥
            agreement.doPhase(publickey,true);
            //生成本地秘钥 keyType1对称加密算法DES/SHA/HMAC
            SecretKey secretKey = agreement.generateSecret(keyType1);
            return secretKey.getEncoded();
        }
    
        /*
         *从Map中获得密钥对
         */
        public static byte[] GetPublicKey(Map<String,Object> map){
            DHPublicKey publicKey = (DHPublicKey) map.get(PUBLIC_KEY);
            return publicKey.getEncoded();
        }
        public static byte[] GetPrivateKey(Map<String,Object> map){
            DHPrivateKey privateKey = (DHPrivateKey) map.get(PRIVATE_KEY);
            return privateKey.getEncoded();
        }
    }

主方法类：

import javafx.scene.effect.DisplacementMap;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Created by cuboo on 2016/10/14.
     */
    public class Main {
        public static void main(String agrs[]) throws Exception {
            Map<String,Object> map = new HashMap<String,Object>();
            Map<String,Object> map1 = new HashMap<String,Object>();
            byte[] data = "jikexueyuan".getBytes();
            //获得A的公钥和私钥
            map = DH_RSA.GenerateKeyPairOfA("DH",512);
            byte[] Apublickey = DH_RSA.GetPublicKey(map);
            byte[] Aprivatekey = DH_RSA.GetPrivateKey(map);
    
            //获得B的公钥和私钥
            map1 = DH_RSA.GenerateKeyPairOfB("DH",Apublickey);
            byte[] Bpublickey = DH_RSA.GetPublicKey(map1);
            byte[] Bprivatekey = DH_RSA.GetPrivateKey(map1);
    
            //获得A的本地秘钥
            byte[] ALocalkey = DH_RSA.GenerateLocalKey("DH","DESede",Bpublickey,Aprivatekey);
            //获得B的本地秘钥
            byte[] BLocalkey = DH_RSA.GenerateLocalKey("DH","DESede",Apublickey,Bprivatekey);
    
            System.out.println("A的公钥："+fromBytesToHexString(Apublickey));
            System.out.println("A的私钥："+fromBytesToHexString(Aprivatekey));
            System.out.println("A的本地秘钥："+fromBytesToHexString(ALocalkey));
            System.out.println("B的公钥："+fromBytesToHexString(Bpublickey));
            System.out.println("B的私钥："+fromBytesToHexString(Bprivatekey));
            System.out.println("B的本地秘钥："+fromBytesToHexString(BLocalkey));
        }
    
        public static String fromBytesToHexString(byte[] data){
            StringBuilder str = new StringBuilder();
            for (int i = 0; i < data.length; i++) {
                 String s = Integer.toHexString(0xFF & data[i]);
                if (s.length() == 1){
                    str.append(0).append(s);
                }else {
                    str.append(s);
                }
            }
            return str.toString();
        }
    
        //十六进制字符串转字节数组
        public static byte[] fromHexStringToBytes(String hexString) {
    
            if ((hexString == null) || (hexString.equals("")) || hexString.length()%2 != 0){
                return null;
            }else{
                hexString = hexString.toUpperCase();
                int length = hexString.length()/2;
                char[] bytec = hexString.toCharArray();
                byte[] bit = new byte[length];
                for (int i = 0; i < length; i++){
                    int p = 2 * i;
                    //两个十六进制字符转换成1个字节，第1个字符转换成byte后左移4位，然后和第2个字符的byte做或运算
                    bit[i] = (byte) (fromCharToByte(bytec[p]) << 4 | fromCharToByte(bytec[p + 1]));
                }
                return bit;
            }
        }
    
        //字符转换为字节
        private static byte fromCharToByte(char c) {
            return (byte) "0123456789ABCDEF".indexOf(c);
        }
    
    }