Java加密-非对称加密

本文内容来自JAVA实现非对称加密

Java加密-非对称加密

非对称加密算法是一种基于密钥的保密方法，需要公开密钥和私有密钥，在文件加密、尤其是网银中应用广泛。

DH

DH(Diffie-Hellman)密钥交换算法

过程：

• 初始化发送方密钥
  
  • KeyPairGenerator用来获取KeyPair
  • KeyPair
  • PublicKey
• 初始化接收方密钥
  
  • KeyFactory
  • X509EncodedKeySpec根据ASN.1标准进行密钥编码
  • DHPublicKey
  • DHParameterSpec
  • KeyPair
  • PrivateKey
• 密钥构建
  
  • KeyAgreement提供密钥一致性（或密钥交换）协议的功能
  • SecretKey
  • KeyFactory
  • X509EncodedKeySpec
  • PublicKey
• 加密、解密
  
  • Cipher

jdk实现方式：

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

        //初始化接收方密钥
        KeyFactory receiveKeyFactory = KeyFactory.getInstance("DH");
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
        PublicKey receivePublicKey = receiveKeyFactory.generatePublic(x509EncodedKeySpec);
        DHParameterSpec dhParameterSpec = ((DHPublicKey)receivePublicKey).getParams();
        KeyPairGenerator receiveKeyPairGenerator = KeyPairGenerator.getInstance("DH");
        receiveKeyPairGenerator.initialize(dhParameterSpec);
        KeyPair receiveKeyPair = receiveKeyPairGenerator.generateKeyPair();
        PrivateKey receivePrivateKey = receiveKeyPair.getPrivate();
        byte[] receiverPublicKeyEnc = receiveKeyPair.getPublic().getEncoded();

        //密钥构建
        KeyAgreement receiveKeyAgreement = KeyAgreement.getInstance("DH");
        receiveKeyAgreement.init(receivePrivateKey);
        receiveKeyAgreement.doPhase(receivePublicKey, true);
        SecretKey receiverDESKey = receiveKeyAgreement.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();
    }
}

DH在实际中的工作流程：

参考：

• Java加密技术（五）DH

RSA

RSA基于因子分解，唯一广泛接受并实现，可以公钥加密、私钥解密，也可以私钥加密、公钥解密。

jdk实现RSA

public static void jdkRSA() {

    try {
        // 1.初始化密钥
        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()));

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

        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));

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

        //解密
        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();
    }

}

RSA流程：

ELGamal

ELGamal基于离散对数

ECC

ECC(Elliptical Curve Cryptography)椭圆曲线加密