非对称加密（DH、RSA、ELGamal）

非对称加密算法属于高等加密、双保险。以下demo演示各个算法的加解密过程

DH密钥交换算法（需要构建本地密钥）；RSA基于因子分解；ELGamal基于离散对数。

均由JDK提供支持，无需导包。

 

其中RSA算法是唯一广泛接受并实现，成为事实上的标准。用于数据加密和数字签名。

支持公钥加密、私钥解密和私钥加密、公钥解密

 

ELGamal因为运行速度较慢，仅作了解

 

1、DH

import org.apache.commons.codec.binary.Base64;

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.Objects;


/**
 * @Author Rhine
 * @Date 2019/1/18 1:30
 **/
public class ImoocDH {

    private static String src="imooc security dh";

    public static void main(String[] args) {
        jdkDH();
    }

    public static void jdkDH(){
        try {
            //1.初始化发送方密钥
            KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();
            byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();//发送方公钥，发送给接收方（网络、文件）


            //2.初始化接受方的密钥
            KeyFactory keyFactory =KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec =new X509EncodedKeySpec(senderPublicKeyEnc);
            PublicKey receiverPublicKey =keyFactory.generatePublic(x509EncodedKeySpec);
            DHParameterSpec dhGenParameterSpec=((DHPublicKey)receiverPublicKey).getParams();

            KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhGenParameterSpec);
            KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();
            PrivateKey receiverPrivateKey = receiverKeyPair.getPrivate();
            byte[] receiverPublicKeyEnc=receiverKeyPair.getPublic().getEncoded();


            //3.密钥构建
            KeyAgreement receiverkeyAgreement =KeyAgreement.getInstance("DH");
            receiverkeyAgreement.init(receiverPrivateKey);
            receiverkeyAgreement.doPhase(receiverPublicKey,true);
            SecretKey receiverDesKey = receiverkeyAgreement.generateSecret("DES");

            KeyFactory senderKeyFactory =KeyFactory.getInstance("DH");
            x509EncodedKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
            PublicKey senderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);
            KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");
            senderKeyAgreement.init(senderKeyPair.getPrivate());
            senderKeyAgreement.doPhase(senderPublicKey,true);

            //发送方的本地密钥
            SecretKey senderDesKey = senderKeyAgreement.generateSecret("DES");

            if (Objects.equals(receiverDesKey,senderDesKey)){
                System.out.println("双方的密钥相同");
            }

            //4.加密
            Cipher cipher=Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);
            byte[] result = cipher.doFinal(src.getBytes());
            System.out.println("jdk dh encrypt: "+ Base64.encodeBase64String(result));

            //5.解密
            cipher.init(Cipher.DECRYPT_MODE,senderDesKey);
            result=cipher.doFinal(result);
            System.out.println("jdk dh decrypt: "+new String(result));

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

 

2、RSA

import org.apache.commons.codec.binary.Base64;

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;

/**
 * @Author Rhine
 * @Date 2019/1/18 20:24
 **/
public class ImoocRSA {
    private static String src="imooc security rsa";

    public static void main(String[] args) {
        jdkRSA();
    }

    public static void jdkRSA(){
        try {
            //1.初始化密钥
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair=keyPairGenerator.genKeyPair();
            RSAPublicKey rsaPublicKey= (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey= (RSAPrivateKey) keyPair.getPrivate();

            System.out.println("Public Key: "+ Base64.encodeBase64String(rsaPublicKey.getEncoded()));
            System.out.println("Private Key: "+ Base64.encodeBase64String(rsaPrivateKey.getEncoded()));

            //2.私钥加密、公钥解密--加密过程
            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.encodeBase64String(result));

            //3.私钥加密、公钥解密--解密过程
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            cipher.init(Cipher.DECRYPT_MODE,publicKey);
            result=cipher.doFinal(result);
            System.out.println("私钥加密、公钥解密--解密： "+new String(result));

            //4.公钥加密、私钥解密--加密
            x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,publicKey);
            result=cipher.doFinal(src.getBytes());
            System.out.println("公钥加密、私钥解密--加密： "+Base64.encodeBase64String(result));

            //5.公钥加密、私钥解密--解密
            pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE,privateKey);
            result=cipher.doFinal(result);
            System.out.println("公钥加密、私钥解密--解密： "+new String(result));


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}