非对称加密DH/RSA/ElGamal

BouncyCastle简称 BC 是第三方包，需下载
DH

public class DHTest {
    private static String src="dddd顶顶顶";
    public static void main(String[] args) {
        jdkDH();
    }

    public static void jdkDH(){
        try{
            //note:需要对方的公钥解密，对方发送过来的加密数据
            //初始化发送方密钥
            KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();
            byte[] senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();//发送方公钥，需要发送给接受方（网络，文件....）

            //使用发送方公钥，初始化接受方密钥
            KeyFactory receiverKeyFactory=KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);
            DHPublicKey receiverPublicKey=(DHPublicKey)receiverKeyFactory.generatePublic(x509EncodedKeySpec);
            DHParameterSpec dhParameterSpec=receiverPublicKey.getParams();
            KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair();
            PrivateKey receiverPrivateKey=receiverKeyPair.getPrivate();
            byte[] receiverPublicKeyEnc=receiverKeyPair.getPublic().getEncoded();//接受方公钥，需要发送给发送方（网络，文件....）

            //密钥构建
            //构建接受方的加解密密钥，
            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("双方密钥相同");

            //加密
            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));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,receiverDESKey);
            result=cipher.doFinal(result);
            System.out.println("jdk DH decrypt: "+new String(result));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

RSA

public class RSATest {
    private static String src="dddddd ddd  订单";
    public static void main(String[] args) {
        jdkRSA();
    }
    public static void jdkRSA(){
        try {
            //初始化密钥
            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.encodeBase64String(rsaPublicKey.getEncoded()));
            System.out.println("Private Key: "+ Base64.encodeBase64String(rsaPrivateKey.getEncoded()));

            //私钥加密，公钥解密--加密
            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));

            //私钥加密，公钥解密--解密
            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));

            //公钥加密，私钥解密--加密

            //公钥加密，私钥解密--解密
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void bcRSA(){
        //重新设置Security.addProvider(new BouncyCastleProvider());
        //剩下的基本一致；所有的 getInstance()指定provider
    }

}

ElGamal

public class ElGamalTest {
    public static void main(String[] args) {
        bcElGamal();
    }
    /*
    只有 Bouncy Castle 提供,仅支持公钥加密，私钥解密
    PKCS8EncodedKeySpec（私钥） X509EncodedKeySpec（公钥）  将密钥的字节数组转成密钥对象
     */
    public static void bcElGamal(){
        try {
            Security.addProvider(new BouncyCastleProvider());
            //初始化密钥
            AlgorithmParameterGenerator algorithmParameterGenerator=AlgorithmParameterGenerator.getInstance("ElGamal");
            algorithmParameterGenerator.init(256);
            AlgorithmParameters algorithmParameters=algorithmParameterGenerator.generateParameters();
            DHParameterSpec dhParameterSpec=algorithmParameters.getParameterSpec(DHParameterSpec.class);

            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("ElGamal");
            keyPairGenerator.initialize(dhParameterSpec,new SecureRandom());
            KeyPair keyPair=keyPairGenerator.generateKeyPair();
            PublicKey elGamalPublicKey=keyPair.getPublic();
            PrivateKey elGamalPrivateKey=keyPair.getPrivate();
            System.out.println("Public Key: "+ Base64.encodeBase64String(elGamalPublicKey.getEncoded()));
            System.out.println("Private Key: "+ Base64.encodeBase64String(elGamalPrivateKey.getEncoded()));

            //转换密钥，公钥加密
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(elGamalPublicKey.getEncoded());
            KeyFactory keyFactory=KeyFactory.getInstance("ElGamal");
            elGamalPublicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            Cipher cipher=Cipher.getInstance("ElGamal");
            cipher.init(Cipher.ENCRYPT_MODE,elGamalPublicKey);
            byte[] result=cipher.doFinal("是了解对方拉".getBytes());
            System.out.println("加密:"+Base64.encodeBase64String(result));

            //私钥解密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(elGamalPrivateKey.getEncoded());
            keyFactory=KeyFactory.getInstance("ElGamal");
            elGamalPrivateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher.init(Cipher.DECRYPT_MODE,elGamalPrivateKey);
            result=cipher.doFinal(result);
            System.out.println("解密："+new String(result));

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

    }
}