java DH密钥交换算法实现类

最新推荐文章于 2023-09-03 17:58:48 发布
最新推荐文章于 2023-09-03 17:58:48 发布
阅读量797 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HH_KELE/article/details/104509915
版权 
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

public class DHUtils {
    /**
     * 非对称加密密钥算法
     */
    private static final String KEY_ALGORITHM = "DH";
    /**
     * 本地密钥算法，即对称加密密钥算法
     * 可选DES、DESede或者AES
     */
    private static final String SELECT_ALGORITHM = "AES";

    /**
     * 默认的加密算法
     */
    private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";


    /**
     * 密钥长度
     */

    private static final int KEY_SIZE = 512;
    //公钥
    private static final String PUBLIC_KEY = "DHPublicKey";
    //私钥
    private static final String PRIVATE_KEY = "DHPrivateKey";

    /**
     * 初始化甲方密钥
     *
     * @return Map 甲方密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        //实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥对生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //甲方公钥
        DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
        //甲方私钥
        DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
        //将密钥对存储在Map中
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * 初始化乙方密钥
     *
     * @param key 甲方公钥
     * @return Map 乙方密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey(byte[] key) throws Exception {
        //解析甲方公钥
        //转换公钥材料
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //由甲方公钥构建乙方密钥
        DHParameterSpec dhParameterSpec = ((DHPublicKey) pubKey).getParams();
        //实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥对生成器
        keyPairGenerator.initialize(dhParameterSpec);
        //产生密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //乙方公钥
        DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
        //乙方私约
        DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
        //将密钥对存储在Map中
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * 生成加密秘钥
     *
     * @return
     */
    private static SecretKeySpec getSecretKey(final byte[] key) {
        //返回生成指定算法密钥生成器的 KeyGenerator 对象
        KeyGenerator kg = null;

        try {
            kg = KeyGenerator.getInstance(SELECT_ALGORITHM);

            //AES 要求密钥长度为 128
            kg.init(128, new SecureRandom(key));

            //生成一个密钥
            SecretKey secretKey = kg.generateKey();

            return new SecretKeySpec(secretKey.getEncoded(), SELECT_ALGORITHM);// 转换为AES专用密钥
        } catch (NoSuchAlgorithmException ex) {
//            Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
        }

        return null;
    }

    /**
     * 加密
     *
     * @param data 待加密数据
     * @param key  密钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key) throws Exception {

        try {
            Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器

            byte[] byteContent = data;

            cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));// 初始化为加密模式的密码器

            byte[] result = cipher.doFinal(byteContent);// 加密
            return result;
//            return org.apache.commons.codec.binary.Base64.encodeBase64String(result);//通过Base64转码返回

        } catch (Exception ex) {
//            Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
        }

        return null;


    }

    /**
     * 解密
     *
     * @param data 待解密数据
     * @param key  密钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] key) throws Exception {

        try {
            //实例化
            Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);

            //使用密钥初始化，设置为解密模式
            cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key));

            //执行操作
            byte[] result = cipher.doFinal(data);

            return result;

        } catch (Exception ex) {
//            Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
        }

        return null;
    }

    /**
     * 构建密钥
     *
     * @param publicKey  公钥
     * @param privateKey 私钥
     * @return byte[] 本地密钥
     * @throws Exception
     */
    public static byte[] getSecretKey(byte[] publicKey, byte[] privateKey) throws Exception {
        //实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey);
        //产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
        //初始化私钥
        //密钥材料转换
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
        //产生私钥
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
        //实例化
        KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory.getAlgorithm());
        //初始化
        keyAgree.init(priKey);
        keyAgree.doPhase(pubKey, true);
        //生成本地密钥
        SecretKey secretKey = keyAgree.generateSecret(SELECT_ALGORITHM);
        return secretKey.getEncoded();
    }

    /**
     * 取得私钥
     *
     * @param keyMap 密钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    /**
     * 取得公钥
     *
     * @param keyMap 密钥Map
     * @return byte[] 公钥
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }


    /**
     * 主方法
     *
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //甲方公钥
        byte[] publicKeyA;
        //甲方私钥
        byte[] privateKeyA;
        //甲方本地密钥
        byte[] localKeyA;
        //乙方公钥
        byte[] publicKeyB;
        //乙方私钥
        byte[] privateKeyB;
        //乙方本地密钥
        byte[] localKeyB;

        //初始化密钥
        //生成甲方密钥对
        Map<String, Object> keyMapA = DHUtils.initKey();
        publicKeyA = DHUtils.getPublicKey(keyMapA);
        privateKeyA = DHUtils.getPrivateKey(keyMapA);
        System.out.println("甲方公钥:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(publicKeyA));
        System.out.println("甲方私钥:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(privateKeyA));
        //由甲方公钥产生乙方本地密钥对
        Map<String, Object> keyMapB = DHUtils.initKey(publicKeyA);
        publicKeyB = DHUtils.getPublicKey(keyMapB);
        privateKeyB = DHUtils.getPrivateKey(keyMapB);
        System.out.println("乙方公钥:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(publicKeyB));
        System.out.println("乙方私钥:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(privateKeyB));
        localKeyA = DHUtils.getSecretKey(publicKeyB, privateKeyA);
        System.out.println("甲方本地密钥:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(localKeyA));
        localKeyB = DHUtils.getSecretKey(publicKeyA, privateKeyB);
        System.out.println("乙方本地密钥:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(localKeyB));

        System.out.println();
        System.out.println("===甲方向乙方发送加密数据===");
        String msgA2B = "求知若饥，虚心若愚。";
        System.out.println("原文:\n" + msgA2B);
        System.out.println("---使用甲方本地密钥对数据进行加密---");
        //使用甲方本地密钥对数据加密
        byte[] encodeMsgA2B = DHUtils.encrypt(msgA2B.getBytes(), localKeyA);
        System.out.println("加密:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(encodeMsgA2B));
        System.out.println("---使用乙方本地密钥对数据库进行解密---");
        //使用乙方本地密钥对数据进行解密
        byte[] msgB2A = DHUtils.decrypt(encodeMsgA2B, localKeyB);
        String output1 = new String(msgB2A);
        System.out.println("解密:\n" + output1);

        System.out.println("/~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~..~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~/");
        System.out.println("===乙方向甲方发送加密数据===");
        String input2 = "好好学习，天天向上。";
        System.out.println("原文:\n" + input2);
        System.out.println("---使用乙方本地密钥对数据进行加密---");
        //使用乙方本地密钥对数据进行加密
        byte[] encode2 = DHUtils.encrypt(input2.getBytes(), localKeyB);
        System.out.println("加密:\n" + org.apache.commons.codec.binary.Base64.encodeBase64String(encode2));
        System.out.println("---使用甲方本地密钥对数据进行解密---");
        //使用甲方本地密钥对数据进行解密
        byte[] decode2 = DHUtils.decrypt(encode2, localKeyA);
        String output2 = new String(decode2);
        System.out.println("解密:\n" + output2);
    }

}

　　输出结果

"C:\Program Files\Java\jdk1.8.0_91\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar=56888:C:\Program Files\JetBrains\IntelliJ IDEA 2019.3.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_91\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_91\jre\lib\rt.jar;Z:\workspace\im\target\test-classes;Z:\.m2\repository\org\apache\commons\commons-lang3\3.9\commons-lang3-3.9.jar;Z:\.m2\repository\commons-codec\commons-codec\1.14\commons-codec-1.14.jar;Z:\.m2\repository\cn\hutool\hutool-all\5.1.4\hutool-all-5.1.4.jar;Z:\.m2\repository\org\bouncycastle\bcprov-jdk15on\1.52\bcprov-jdk15on-1.52.jar" DHUtils
甲方公钥:
MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBANKee3tUIVRpwpLj+Kfqe5t8w4QIM54k94fKcp2Alg/kWLm4bEBTvWv4XMKIH13k9eQcvTRxVuqxdkS62yi1guc=
甲方私钥:
MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEA/cVM7DmzLK7gijP61uR2ipNjP/tG84kCZJzt10KM8XPpvvKGDa6c000GO3dNliIC
乙方公钥:
MIHgMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANEAAJBAJIS3ho3UENwFuQwrB3uPXS0q9K+0Box8fdGeCdj10uyT0vSV+TgoO6IhX11k535QfBMvh8cHR4BrYo7LSC/wdY=
乙方私钥:
MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAyMLT94TotoWZCPvaJpT3VYlQ3TgwJvo7Mc/gsbdTBIQKQRIRhEZ1MCpn8is83CKh
甲方本地密钥:
SZb1nFDuDT34Q9WkIb7bNVndlSOfHa0s55ZbxuldNhQ=
乙方本地密钥:
SZb1nFDuDT34Q9WkIb7bNVndlSOfHa0s55ZbxuldNhQ=

===甲方向乙方发送加密数据===
原文:
求知若饥，虚心若愚。
---使用甲方本地密钥对数据进行加密---
加密:
5cORf8g/pkzIvSPd7sNn0yWkOjx0JQvzwYaKR0/ox2c=
---使用乙方本地密钥对数据库进行解密---
解密:
求知若饥，虚心若愚。
/~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~..~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~.~/
===乙方向甲方发送加密数据===
原文:
好好学习，天天向上。
---使用乙方本地密钥对数据进行加密---
加密:
Mh08mY3CwWCJowGf8t/ZPaNJUxJpcAifHepADby3kTs=
---使用甲方本地密钥对数据进行解密---
解密:
好好学习，天天向上。

Process finished with exit code 0

　　

HH_KELE
关注
密钥协商算法Diffie-Hellman的Java实现
厚积薄发者，轻舟万重山
03-03 4438
本文的思路是这样的：先了解Diffie-Hellman的流程原理，然后将其流程和Java的实现对应起来；理解了原理和Java实现的流程，再写应用代码进一步辅助验证，最后走一走源码流程中的相关细节，做最终验证；最后，再了解一下性能更好、安全性更高的ECDH（基于椭圆曲线来实现的Diffie-Hellman）
DiffieHillman密钥交换算法 C/C++实现
qq_694060865的博客
09-12 9056
DH密钥交换算法因为不能验证数据的来源,所以不能抵御中间人击. 如果需要安全强度更高的非对称加密算法,可以采用Ecc椭圆曲线加密算法或者使用广泛的RSA加密算法.       不对称加密算法主要用于在公共网络安全的数据传输.      不对称加密算法关键部分在于大整数数学函数库的使用.      C/C++实现的DH算法动态链接库,需要64位的可以自己手动编译.      git
DH密钥交换算法Java实现
01-06
DH密钥交换算法这个机制的巧妙在于它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道确定对称密钥。 我用Java写了两个例子，有需要的可以看看。
java-信息安全（八）-迪菲-赫尔曼（DH）密钥交换【不推荐，推荐Oakley】
dilv4062的博客
03-17 541
概述 信息安全基本概念： DH(Diffie–Hellman key exchange,迪菲-赫尔曼密钥交换) DH 　　是一种安全协议,,一种确保共享KEY安全穿越不安全网络的方法，它是OAKLEY的一个组成部分。 　　这个机制的巧妙在于需要安全通信的双方可以用这个方法确定对称密钥。然后可以用这个密钥进行加密和解密。但是注意，这个密钥交换协议/算法只能用于密钥的交换，...
java dh密钥交换_java-信息安全（八）-迪菲-赫尔曼（DH）密钥交换
weixin_31507527的博客
02-26 512
概述信息安全基本概念：DH(Diffie–Hellman key exchange,迪菲-赫尔曼密钥交换)DH是一种安全协议,,一种确保共享KEY安全穿越不安全网络的方法，它是OAKLEY的一个组成部分。这个机制的巧妙在于需要安全通信的双方可以用这个方法确定对称密钥。然后可以用这个密钥进行加密和解密。但是注意，这个密钥交换协议/算法只能用于密钥的交换，而不能进行消息的加密和解密。双方确定要用的密钥...
Java笔记-DH密钥交换
IT1995的博客
08-17 957
DH密钥交换主要是两个公式的编写，即： ·公钥计算公式； ·密钥计算公式； 生成随机数作为私钥 截图如下： 源码如下： DH.java package cn.it1995.tool; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Random; public class DH { private ...
DH秘钥交换算法
05-15
基于NTL算法库C++实现 &里面包含NTL算法库的静态库文件
DH.rar_DH_DH java_DH密钥交换
09-24
在这个DH.rar文件中，包含了与DH算法在Java环境下实现相关的代码和资源，用于测试和验证DH密钥交换的过程。 DH算法的核心思想是，两个通信方（通常被称为Alice和Bob）可以共享一个只有他们两人才能解密的密钥，而...
java 非对称加密算法DH实现详解
08-25
Java 非对称加密算法 DH 实现详解是一种基于 Diffie-Hellman 密钥交换算法的非对称加密算法实现。该算法实现了密钥交换、加密和解密的过程，主要用于保证数据的安全传输。 Diffie-Hellman 算法简介 Diffie-Hellman...
秘钥交换算法
最新发布
2301_77661292的博客
09-03 236
对称加密算法解决了数据加密的问题。我们以AES加密为例：在现实世界中，Alice要向Bob发送一个加密文件，Alice可以先生成一个AES密钥，对文件进行加密，然后把加密文件发送给Bob。因为Bob要解密，就必须需要Alice生成的密钥。现在问题来了：如何传递密钥？在不安全的信道上传递加密文件是没有问题的，因为黑客拿到加密文件没有用。但是，如何在不安全的信道上安全地传输密钥？
java密钥交换算法DH定义与应用实例分析
08-25
主要介绍了java密钥交换算法DH定义与应用,结合实例形式分析了Java密钥交换算法DH的原理、定义、使用方法及相关操作注意事项,需要的朋友可以参考下
java dh_Java DH密钥交换及加解密
weixin_42356978的博客
02-23 459
描述DH算法的作用：只能用于密钥的交换，而不能进行消息的加密和解密。密钥交换的过程：image.png具体步骤：1)由消息发送的一方构建密钥，这里由甲方构建密钥。2)由构建密钥的一方向对方公布其公钥，这里由甲方向乙方发布公钥。3)由消息接收的一方通过对方公钥构建自身密钥，这里由乙方使用甲方公钥构建乙方密钥。4)由消息接收的一方向对方公布其公钥，这里由乙方向甲方公布公钥。5)甲方根据自己的私钥和乙方...
java安全架构____DH秘钥加密解密
蜜獾互联网
02-26 527
//转自IBM Chain 社区 https://www.ibm.com/developerworks/cn/java/l-security/index.html import java.security.*; import java.security.spec.*; import java.util.Arrays; import javax.crypto.*; import javax.cr
java dh算法_dh密钥交换算法java
weixin_29495679的博客
02-16 641
dh密钥交换算法java迪菲－赫尔曼密钥交换(Diffie–Hellman key exchange，简称“D–H”) 是一种安全协议。它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道建立起一个密钥。这个密钥可以在后续的通讯中作为对称密钥来加密通讯内容。(1)、算法描述离散对数的概念：原根：如果a是素数p的一个原根，那么数值：amodp，a^2 modp，…，a^(p-1) modp是...
非对称性密钥加密 java 实例_JAVA加密算法（4）- 非对称加密算法（DH，RSA）
weixin_36330518的博客
02-13 285
非对称密码概念发送者使用接收者的公钥加密，接收者使用自己的私钥解密。需要两个密钥进行加密或解密，分为公钥和私钥特点：安全性高，速度慢常用算法DH密钥交换算法RSA算法ElGamal算法那用途密钥交换(DH)双方在没有确定共同密钥的情况下，生成密钥，不提供加密工作，加解密还需要其他对称加密算法实现加密/解密(RSA)数字签名(RSA)DH算法示例import javax.crypto.KeyAgre...
java dh_非对称式加密在JAVA中的实现（DH加密） - java实现非对称加密算法的过程...
weixin_36087905的博客
02-15 271
4. 非对称式加密在JAVA中的实现(DH加密)：［java］ view plain copypublic class DH {private static String src=“security with DH”;public static void main(String［］ args){jdkDH();}public static void jdkDH(){try {//初始化发送方密钥K...
javah详解
顺其自然~专栏
11-22 4475
java开发中如果使用到JNI,则难免需要使用javah来生成C++或C的头文件信息，下面就讲解javah的命令： 第一种：直接cd到当前程序的target/class目录下（一定不能是子目录）（maven项目，如果是普通项目则到bin目录下） 。然后使用：javah com.yongcheng.liuyang.utils.TestJni，其中javah后面的是需要生成头文件类的全路径（包名+类名），当然生成的.h文件位于当前class的目录下。 第二种：直接在运行中cmd到dos窗口，使用如下命令：j
每日一得--非对称加密算法之（DH）
xoopx的专栏
03-12 538
一，实现对称加密算法的方式：jdk实现方式 import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值