JAVA加密算法（4）- 非对称加密算法（DH，RSA）

Lucky_Boy 发布于2019-08-14 16:38 / 1253人阅读

摘要：非对称密码概念发送者使用接收者的公钥加密，接收者使用自己的私钥解密。

非对称密码概念

发送者使用接收者的公钥加密，接收者使用自己的私钥解密。

需要两个密钥进行加密或解密，分为公钥和私钥

特点：安全性高，速度慢

常用算法

DH密钥交换算法

RSA算法

ElGamal算法那

用途

密钥交换（DH）

双方在没有确定共同密钥的情况下，生成密钥，不提供加密工作，加解密还需要其他对称加密算法实现

加密/解密（RSA）

数字签名（RSA）

DH算法示例

import javax.crypto.KeyAgreement;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

//1 生成源密钥
//2 把源公钥交给目标，目标通过源公钥，生成目标公钥和私钥
//3 把目标公钥交给源
//4 双方使用对方的公钥和和自己的私钥，生成本地密钥
//5 如果双方生成本地密钥相同则完成密钥交换
public class DHUtil {

    public static final String PUBLIC_KEY = "DH_Public_Key";
    public static final String PRIVATE_KEY = "DH_Private_key";

    /**
     * 生成源密钥对
     * @return
     * @throws Exception
     */
    public static Map initSourceKey() throws Exception{
        //创建KeyPairGenerator的实例，选用DH算法
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");

        //初始化密钥长度，默认1024，可选范围512-65536 & 64的倍数
        keyPairGenerator.initialize(1024);

        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        DHPublicKey dhPublicKey = (DHPublicKey) keyPair.getPublic();
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyPair.getPrivate();

        //将密钥对放入Map
        Map keyMap = new HashMap();
        keyMap.put(PUBLIC_KEY, dhPublicKey);
        keyMap.put(PRIVATE_KEY, dhPrivateKey);
        return keyMap;
    }

    /**
     * 通过源公钥 生成 目标密钥对
     * @param sourcePublicKey
     * @return
     * @throws Exception
     */
    public static Map initTargetKey(byte[] sourcePublicKey) throws Exception {

        KeyFactory keyFactory = KeyFactory.getInstance("DH");

        //通过源公钥，生成keySpec，使用KeyFactory生成源PublicKey相关信息
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(sourcePublicKey);
        DHPublicKey sourcePublic = (DHPublicKey) keyFactory.generatePublic(keySpec);

        DHParameterSpec dhPublicKeyParams = sourcePublic.getParams();

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("DH");
        keyPairGenerator.initialize(dhPublicKeyParams);

        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        DHPublicKey dhPublicKey = (DHPublicKey) keyPair.getPublic();
        DHPrivateKey dhPrivateKey = (DHPrivateKey) keyPair.getPrivate();

        //将密钥对放入Map
        Map keyMap = new HashMap();
        keyMap.put(PUBLIC_KEY, dhPublicKey);
        keyMap.put(PRIVATE_KEY, dhPrivateKey);
        return keyMap;
    }

    /**
     * 使用一方的公钥和另一方的私钥，生成本地密钥
     * @return
     */
    public static byte[] generateLocalSecretKey(byte[] aPublicKey, byte[] bPrivateKey) throws Exception{
        KeyFactory keyFactory = KeyFactory.getInstance("DH");

        //通过A公钥，生成keySpec，使用KeyFactory生成A PublicKey相关信息
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(aPublicKey);
        PublicKey publicKey = keyFactory.generatePublic(keySpec);

        //通过B私钥，生成B PrivateKey相关信息
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(bPrivateKey);
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        //通过KeyAgreement对A的PublicKey和B的PrivateKey进行加密
        KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
        keyAgreement.init(privateKey);
        keyAgreement.doPhase(publicKey,true);


        return keyAgreement.generateSecret("AES").getEncoded();//算法使用对称加密算法（DES，DESede，AES）
        //return keyAgreement.generateSecret();                // 也可以不选择算法，使用默认方法计算
    }

    //获取公钥字节数组
    public static byte[] getPublicKey(Map map){
        return ((DHPublicKey) map.get(PUBLIC_KEY)).getEncoded();
    }

    //获取私钥字节数组
    public static byte[] getPrivateKey(Map map){
        return ((DHPrivateKey) map.get(PRIVATE_KEY)).getEncoded();
    }

    public static void main(String[] args) throws Exception {

        byte[] source_public_key;
        byte[] source_private_key;
        byte[] source_local_key;

        byte[] target_public_key;
        byte[] target_private_key;
        byte[] target_local_key;

        Map sourceKey = initSourceKey();
        source_public_key = getPublicKey(sourceKey);
        source_private_key = getPrivateKey(sourceKey);

        System.out.println("源公钥："+BytesToHex.fromBytesToHex(source_public_key));
        System.out.println("源私钥："+BytesToHex.fromBytesToHex(source_private_key));

        Map targetKey = initTargetKey(getPublicKey(sourceKey));
        target_public_key = getPublicKey(targetKey);
        target_private_key = getPrivateKey(targetKey);

        System.out.println("目标公钥："+BytesToHex.fromBytesToHex(target_public_key));
        System.out.println("目标私钥："+BytesToHex.fromBytesToHex(target_private_key));

        source_local_key = generateLocalSecretKey(target_public_key, source_private_key);
        target_local_key = generateLocalSecretKey(source_public_key, target_private_key);

        System.out.println("源本地密钥："+BytesToHex.fromBytesToHex(source_local_key));
        System.out.println("目标本地密钥："+BytesToHex.fromBytesToHex(target_local_key));
    }
}

RSA 加密/解密示例

公钥加密，私钥解密

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA加密工具
 */
public class RSAUtil {

    public static final String PUBLIC_KEY = "RSA_Public_Key";
    public static final String PRIVATE_KEY = "RSA_Private_Key";

    /**
     * 初始化密钥
     * @return
     * @throws Exception
     */
    public static Map initKey() throws Exception{
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(1024);//512-65536 & 64的倍数
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map keyMap = new HashMap();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    public static RSAPublicKey getPublicKey(Map keyMap) {
        return (RSAPublicKey) keyMap.get(PUBLIC_KEY);
    }

    public static RSAPrivateKey getPrivateKey(Map keyMap){
        return (RSAPrivateKey) keyMap.get(PRIVATE_KEY);
    }

    /**
     * 使用公钥对数据进行加密
     * @param data
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, RSAPublicKey publicKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE,publicKey);
        return cipher.doFinal(data);
    }

    /**
     * 使用私钥解密
     * @param data
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, RSAPrivateKey privateKey) throws Exception{
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        return cipher.doFinal(data);
    }

    public static void main(String[] args) throws Exception {
        String data = "周杰伦-东风破";
        Map keyMap = initKey();

        byte[] miwen = encrypt(data.getBytes(),getPublicKey(keyMap));
        System.out.println("加密后的内容："+BytesToHex.fromBytesToHex(miwen));

        byte[] plain = decrypt(miwen, getPrivateKey(keyMap));
        System.out.println("解密后的内容："+new String(plain));

    }
}

海外云主机 GPU服务器非对称加密算法字符串的非对称加密算法 rsa非对称加密对称加密算法

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/66233.html

慕课网_《Java实现非对称加密》学习总结

摘要：时间年月日星期三说明本文部分内容均来自慕课网。秘密密钥，生成一个分组的秘密密钥。时间：2017年4月12日星期三说明：本文部分内容均来自慕课网。@慕课网：http://www.imooc.com教学示例源码：https://github.com/zccodere/s...个人学习源码：https://github.com/zccodere/s... 第一章：概述 1-1 概述非对称...

dailybird 2019-08-14 18:09 评论0 收藏0
没那么浅地谈谈HTTP与HTTPS【三】

摘要：公开密钥加密的出现大大减轻了交换对称密钥的困难，公钥可以公开透过不安全可被窃听的渠道发送，用以加密明文。当与配合使用，称之为，与配合则称为，以此类推。这步没有签名，服务端收到数据后不会发现被篡改。对于认证机构，一旦私钥外泄，将可能导致整未济，亨。小狐汔济，濡其尾，无攸利。——《易》六、密钥管理当不再担心身份会被冒充、篡改之后，我们再来详细谈谈网络通信中对于加密算法的密钥管理。在密钥被签发后，...

Tecode 2022-06-28 18:59 评论0 收藏0
JAVA加密算法（1）- 密码学概述及BASE64算法使用

密码学综述密码学基本功能机密性、鉴别、报文完整性、不可否认性基本模型 sender-->加密算法 --> 密文 --> 解密算法 --> receiver 密钥源密码学算法分类：消息编码：Base64 消息摘要：MD类，SHA类，MAC 对称加密：DES，3DES，AES 非对称加密：RSA，DH密钥交换数字签名：RSA signature，DSA signature 密码学...

sevi_stuo 2019-08-14 14:57 评论0 收藏0
Swoole 源码分析——Server模块之OpenSSL (上)

摘要：另一方比如小明得到公钥之后，双方就可以通信。然而，中间人还是可能截获公钥，然后自己弄一对秘钥，然后告诉小明说是小红的公钥。这样，小亮在签署小红的身份证的时候，可以在小红身份证后面附上自己的身份证。一般来说，自签名的根身份证用于公司内部使用。前言自从 Lets Encrypt 上线之后，HTTPS 网站数量占比越来越高，相信不久的未来就可以实现全网 HTTPS，大部分主流浏览器也对 ...

ky0ncheng 2019-07-01 12:31 评论0 收藏0