【Java小工匠聊密码学】--非对称加密--DH密钥交换算法

简介: 1、DH密钥交换概述Diffie-Hellman由Whitfield Diffie和Martin Hellman在1976年公布的一种密钥一致性算法。Diffie-Hellman是一种建立密钥的方法,而不是加密方法。

1、DH密钥交换概述

Diffie-Hellman由Whitfield Diffie和Martin Hellman在1976年公布的一种密钥一致性算法。Diffie-Hellman是一种建立密钥的方法,而不是加密方法。然而,它所产生的密钥可用于加密、进一步的密钥管理或任何其它的加密方式。Diffie-Hellman密钥交换算法及其优化首次发表的公开密钥算法出现在Diffie和Hellman的论文中,这篇影响深远的论文奠定了公开密钥密码编码学。

2、DH密钥交换算法原理

2.1、使用颜色形象描述

设想这样一个场景,Alice(A)和Bob(B),他们想在不见面的情况下秘密约定出一种颜色,但他们互相沟通的信息都会被公开,应该怎么办呢?


DH密钥交换算法

秘密在于,颜色混合是一种“不可逆”的操作,当双方交换颜色时,尽管我们知道他们交换的颜色都是由一份黄色和另一份其他颜色混合得到的,但我们还是无法或者很难得到他们的私密颜色。

2.2、数学算法

2.2.1 算法背景

乘方得逆运算称为对数运算,比如已知 7^x = 49 那么可知 x=log(7,49)=2。 对数运算非常容易,即使在数字很大的时候是,但如果是下面的情况 7^xmod13=8 。 求X的过程称为“离散对数”,就不那么容易了,在数字很大时几乎是一个不可能的运算,而DH秘钥交换就是利用了这种离散对数计算非常困难的特性来设计的。

2.2.2 取模运算规律

公式里的mod是取模运算,取模运算有几条基本的定律如下:
(a+b) mod P =(a mod P+b mod P) mod P
(a∗b) mod P = (a mod P∗b mod P) mod P
(a^b) mod P = (a mod P)^b) mod P

2.2.3 密钥交换流程

根据上面的公式,可以推导出一个非常重要的公式。
(G^(a∗b)) mod P=(G^a mod P)^b mod P=(G^b mod P)^a mod P
根据这个公式,我们可以向上面交换颜色那样设计出一个秘密交换数字的流程出来。


交换流程

最终两个人得到的秘密数字都是g^(ab) mod p,而窃听者仅从p,g,A,B四个公开信息,是无法得到这个秘密数字的!

2.2.4举例说明

第1步.爱丽丝与鲍伯协定使用p=23以及g=5.
第2步.爱丽丝选择一个秘密整数a=6, 计算A = g^a mod p并发送给鲍伯。 A = 5^6 mod 23 = 8.
第3步.鲍伯选择一个秘密整数b=15, 计算B = g^b mod p并发送给爱丽丝。
B = 5^15 mod 23 = 19.
第4步.爱丽丝计算
s = B a mod p
19^6 mod 23 = 2.
第5步.鲍伯计算s = A b mod p
8^15 mod 23 = 2.

3、DH密钥交换算用途

可以用作对称加密算法中,双方约定的加密准则的交换(对方的公钥和自己的私钥计算的到秘密整数,可以作为双方的加密准则)。交换双方可以在不共享任何秘密的情况下协商出一个密钥。

4、中间人攻击

由于密钥交换本身并没有提供通讯双方的身份验证服务,因此它很容易受到中间人攻击。 一个中间人“丙”在信道的中央进行两次迪菲-赫尔曼密钥交换,一次和甲,另一次和乙,就能够成功的向甲假装自己是乙,反之亦然。而攻击者可以解密(读取和存储)任何一个人的信息并重新加密信息,然后传递给另一个人。因此通常都需要一个能够验证通讯双方身份的机制来防止这类攻击。

5、算法实现

5.1、JDK算法实现

package lzf.cipher;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;

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

/**
 * @author java小工匠
 */
public class DHUtils {

    // 甲方初始化密钥对
    public static KeyPair initKey() {
        try {
            // 实例化密钥对生成器
            KeyPairGenerator generator = KeyPairGenerator.getInstance("DH");
            // 初始化密钥对生成器参数 默认1024 512-1024之间64的倍数
            generator.initialize(1024);
            // 产生密钥对
            KeyPair keyPair = generator.genKeyPair();
            return keyPair;
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    // 乙方初始化密钥生成对
    public static KeyPair initKey(byte[] key) {
        try {
            // 公钥从字节数组转换为PublicKey
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(key);
            // 实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance("DH");
            // 还原甲方的公钥
            DHPublicKey dhPublicKey = (DHPublicKey) keyFactory.generatePublic(keySpec);
            // 剖析甲方公钥,得到其参数
            DHParameterSpec dhParameterSpec = dhPublicKey.getParams();
            // 实例化密钥对生成器
            KeyPairGenerator generator = KeyPairGenerator.getInstance("DH");
            // 使用得到的参数,初始化密钥生成器
            generator.initialize(dhParameterSpec);
            return generator.generateKeyPair();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    // 获取公钥
    public static byte[] getPublicKey(KeyPair keyPair) {
        byte[] bytes = keyPair.getPublic().getEncoded();
        return bytes;
    }

    // 获取公钥
    public static String getPublicKeyStr(KeyPair keyPair) {
        byte[] bytes = keyPair.getPublic().getEncoded();
        return Hex.encodeHexString(bytes);
    }

    // 获取私钥
    public static byte[] getPrivateKey(KeyPair keyPair) {
        byte[] bytes = keyPair.getPrivate().getEncoded();
        return bytes;
    }

    // 获取公钥
    public static String getPrivateKeyStr(KeyPair keyPair) {
        byte[] bytes = keyPair.getPrivate().getEncoded();
        return Hex.encodeHexString(bytes);
    }

    // 生成本地密钥
    public static byte[] getSecretKey(byte[] publicKey, byte[] privateKey) {
        try {
            // 实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance("DH");
            // 将公钥从字节数组转换为PublicKey
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
            PublicKey pubKey = keyFactory.generatePublic(keySpec);
            // 将私钥从字节数组转换为PrivateKey
            PKCS8EncodedKeySpec privateSpec = new PKCS8EncodedKeySpec(privateKey);
            PrivateKey priKey = keyFactory.generatePrivate(privateSpec);
            // 先实例化KeyAgreement
            KeyAgreement keyAgreement = KeyAgreement.getInstance("DH");
            // 用自己的私钥初始化keyAgreement
            keyAgreement.init(priKey);
            // 结合对方的公钥进行运算
            keyAgreement.doPhase(pubKey, true);
            // 开始生成本地密钥SecretKey 密钥算法为对称密码算法
            SecretKey key = keyAgreement.generateSecret("AES");
            return key.getEncoded();
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage(), e);
        }
    }

    public static void main(String[] args) {
        KeyPair keyPair1 = initKey();
        byte[] publicKey1 = getPublicKey(keyPair1);
        String publicKeyStr1 = Hex.encodeHexString(publicKey1);
        byte[] privateKey1 = getPrivateKey(keyPair1);
        String privateKeyStr1 = Hex.encodeHexString(privateKey1);
        System.out.println("甲方公钥:" + publicKeyStr1);
        System.out.println("甲方私钥:" + privateKeyStr1);
        KeyPair keyPair2 = initKey(publicKey1);
        byte[] publicKey2 = getPublicKey(keyPair2);
        String publicKeyStr2 = Hex.encodeHexString(publicKey2);
        byte[] privateKey2 = getPrivateKey(keyPair2);
        String privateKeyStr2 = Hex.encodeHexString(privateKey2);
        System.out.println("乙方公钥:" + publicKeyStr2);
        System.out.println("乙方私钥:" + privateKeyStr2);
        byte[] secrectKey1 = getSecretKey(publicKey2, privateKey1);
        byte[] secrectKey2 = getSecretKey(publicKey1, privateKey2);
        String secrectKeyStr1 = Hex.encodeHexString(secrectKey1);
        String secrectKeyStr2 = Hex.encodeHexString(secrectKey2);
        System.out.println("甲方协议密钥:"+secrectKeyStr1);
        System.out.println("乙方协议密钥:"+secrectKeyStr2);
        System.out.println("甲=乙:"+secrectKeyStr1.equals(secrectKeyStr2));

    }
}

如果读完觉得有收获的话,欢迎点赞、关注、加公众号【小工匠技术圈】

个人公众号,欢迎关注,查阅更多精彩历史!

image
相关文章
|
4月前
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
本文聚焦 MySQL 集群架构中的负载均衡算法,阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法,分析各自优缺点及适用场景。并提供 Java 语言代码实现示例,助力直观理解。文章结构清晰,语言通俗易懂,对理解和应用负载均衡算法具有实用价值和参考价值。
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
|
4月前
|
人工智能 算法 NoSQL
LRU算法的Java实现
LRU(Least Recently Used)算法用于淘汰最近最少使用的数据,常应用于内存管理策略中。在Redis中,通过`maxmemory-policy`配置实现不同淘汰策略,如`allkeys-lru`和`volatile-lru`等,采用采样方式近似LRU以优化性能。Java中可通过`LinkedHashMap`轻松实现LRUCache,利用其`accessOrder`特性和`removeEldestEntry`方法完成缓存淘汰逻辑,代码简洁高效。
188 0
|
8月前
|
存储 算法 安全
探究‘公司禁用 U 盘’背后的哈希表算法与 Java 实现
在数字化办公时代,信息安全至关重要。许多公司采取“禁用U盘”策略,利用哈希表算法高效管理外接设备的接入权限。哈希表通过哈希函数将设备标识映射到数组索引,快速判断U盘是否授权。例如,公司预先将允许的U盘标识存入哈希表,新设备接入时迅速验证,未授权则禁止传输并报警。这有效防止恶意软件和数据泄露,保障企业信息安全。 代码示例展示了如何用Java实现简单的哈希表,模拟公司U盘管控场景。哈希表不仅用于设备管理,还在文件索引、用户权限等多方面助力信息安全防线的构建,为企业数字化进程保驾护航。
|
3月前
|
存储 Java 数据安全/隐私保护
Java技术栈揭秘:Base64加密和解密文件的实战案例
以上就是我们今天关于Java实现Base64编码和解码的实战案例介绍。希望能对你有所帮助。还有更多知识等待你去探索和学习,让我们一同努力,继续前行!
312 5
|
11月前
|
存储 人工智能 算法
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
这篇文章详细介绍了Dijkstra和Floyd算法,这两种算法分别用于解决单源和多源最短路径问题,并且提供了Java语言的实现代码。
608 3
数据结构与算法细节篇之最短路径问题:Dijkstra和Floyd算法详细描述,java语言实现。
|
7月前
|
存储 缓存 Java
java语言后台管理ruoyi后台管理框架-登录提示“无效的会话,或者会话已过期,请重新登录。”-扩展知识数据库中密码加密的方法-问题如何解决-以及如何重置若依后台管理框架admin密码-优雅草卓伊凡
java语言后台管理ruoyi后台管理框架-登录提示“无效的会话,或者会话已过期,请重新登录。”-扩展知识数据库中密码加密的方法-问题如何解决-以及如何重置若依后台管理框架admin密码-优雅草卓伊凡
772 3
java语言后台管理ruoyi后台管理框架-登录提示“无效的会话,或者会话已过期,请重新登录。”-扩展知识数据库中密码加密的方法-问题如何解决-以及如何重置若依后台管理框架admin密码-优雅草卓伊凡
|
11月前
|
Java Maven 数据安全/隐私保护
如何实现Java打包程序的加密代码混淆,避免被反编译?
【10月更文挑战第15天】如何实现Java打包程序的加密代码混淆,避免被反编译?
1930 2
|
11月前
|
算法 Java 数据中心
探讨面试常见问题雪花算法、时钟回拨问题,java中优雅的实现方式
【10月更文挑战第2天】在大数据量系统中,分布式ID生成是一个关键问题。为了保证在分布式环境下生成的ID唯一、有序且高效,业界提出了多种解决方案,其中雪花算法(Snowflake Algorithm)是一种广泛应用的分布式ID生成算法。本文将详细介绍雪花算法的原理、实现及其处理时钟回拨问题的方法,并提供Java代码示例。
878 2
|
11月前
|
安全 算法 Java
数据库信息/密码加盐加密 —— Java代码手写+集成两种方式,手把手教学!保证能用!
本文提供了在数据库中对密码等敏感信息进行加盐加密的详细教程,包括手写MD5加密算法和使用Spring Security的BCryptPasswordEncoder进行加密,并强调了使用BCryptPasswordEncoder时需要注意的Spring Security配置问题。
801 0
数据库信息/密码加盐加密 —— Java代码手写+集成两种方式,手把手教学!保证能用!
|
存储 算法 Java
在Java中使用MD5对用户输入密码进行加密存储、同时登录验证。
这篇文章详细介绍了在Java项目中如何使用MD5算法对用户密码进行加密存储和登录验证,包括加入依赖、编写MD5工具类、注册时的密码加密和登录时的密码验证等步骤,并通过示例代码和数据库存储信息展示了测试效果。
在Java中使用MD5对用户输入密码进行加密存储、同时登录验证。