package test.common;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
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 org.apache.commons.codec.binary.Base64;
/**
* 非对称加密算法DH算法组件
* 非对称算法一般是用来传送对称加密算法的密钥来使用的,所以这里我们用DH算法模拟密钥传送
* 原理:甲方生产随机公私钥,乙方用甲方的公钥生成乙方的公私钥对
* 甲方用甲方的私钥和乙方的公钥生成密钥,乙方用乙方的私钥和甲方的公钥生成密钥
* 甲乙双方在用密钥DES对称加密
* 对称加密DES算法继续做我们的数据加解密
* @author nicaisheng
*
*/
public class DHCoderTest {
//非对称密钥算法
public static final String KEY_ALGORITHM = "DH";
//本地密钥算法,即对称加密算法。可选des,aes,desede
public static final String SECRET_ALGORITHM = "DES";
/**
* 密钥长度,DH算法的默认密钥长度是1024
* 密钥长度必须是64的倍数,在512到1024位之间
* */
private static final int KEY_SIZE = 512;
//公钥
private static final String PUBLIC_KEY="DHPublicKey";
//私钥
private static final String PRIVATE_KEY="DHPrivateKey";
/**
* 初始化甲方密钥
* @return
* @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>();
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 初始化乙方密钥
* @param key 甲方密钥(这个密钥是通过第三方途径传递的)
* @return Map 乙方密钥的Map
* */
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 dhParamSpec = ((DHPublicKey)pubKey).getParams();
//实例化密钥生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyFactory.getAlgorithm());
//初始化密钥生成器
keyPairGenerator.initialize(dhParamSpec);
//产生密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
//乙方公钥
DHPublicKey publicKey=(DHPublicKey)keyPair.getPublic();
//乙方私钥
DHPrivateKey privateKey=(DHPrivateKey)keyPair.getPrivate();
//将密钥存储在Map中
Map<String,Object> keyMap=new HashMap<String,Object>();
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 加密
* @param data待加密数据
* @param key 密钥
* @return byte[] 加密数据
* */
public static byte[] encrypt(byte[] data,byte[] key) throws Exception{
//生成本地密钥
SecretKey secretKey = new SecretKeySpec(key,SECRET_ALGORITHM);
//数据加密
Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
return cipher.doFinal(data);
}
/**
* 解密
* @param data 待解密数据
* @param key 密钥
* @return byte[] 解密数据
* */
public static byte[] decrypt(byte[] data,byte[] key) throws Exception{
//生成本地密钥
SecretKey secretKey=new SecretKeySpec(key,SECRET_ALGORITHM);
//数据解密
Cipher cipher=Cipher.getInstance(secretKey.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, secretKey);
return cipher.doFinal(data);
}
/**
* 构建密钥
* @param publicKey 公钥
* @param privateKey 私钥
* @return byte[] 本地密钥
* */
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(SECRET_ALGORITHM);
return secretKey.getEncoded();
}
/**
* 取得私钥
* @param keyMap 密钥map
* @return byte[] 私钥
* */
public static byte[] getPrivateKey(Map<String,Object> keyMap){
Key key=(Key)keyMap.get(PRIVATE_KEY);
return key.getEncoded();
}
/**
* 取得公钥
* @param keyMap 密钥map
* @return byte[] 公钥
* */
public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
Key key=(Key) keyMap.get(PUBLIC_KEY);
return key.getEncoded();
}
public static void main(String[] args) throws Exception {
//生成甲方的密钥对
Map<String,Object> keyMap1 = DHCoderTest.initKey();
byte[] publicKey1 = DHCoderTest.getPublicKey(keyMap1);
byte[] privateKey1 = DHCoderTest.getPrivateKey(keyMap1);
System.out.println("甲方公钥:"+Base64.encodeBase64String(publicKey1));
System.out.println("甲方私钥:"+Base64.encodeBase64String(privateKey1));
//由甲方的公钥产生的密钥对
Map<String,Object> keyMap2 = DHCoderTest.initKey(publicKey1);
byte[] publicKey2 = DHCoderTest.getPublicKey(keyMap2);
byte[] privateKey2 = DHCoderTest.getPrivateKey(keyMap2);
System.out.println("乙方公钥:"+Base64.encodeBase64String(publicKey2));
System.out.println("乙方私钥:"+Base64.encodeBase64String(privateKey2));
//组装甲方的本地加密密钥,由乙方的公钥和甲方的私钥组合而成
byte[] key1=DHCoderTest.getSecretKey(publicKey2, privateKey1);
System.out.println("甲方的本地密钥:"+Base64.encodeBase64String(key1));
//组装乙方的本地加密密钥,由甲方的公钥和乙方的私钥组合而成
byte[] key2=DHCoderTest.getSecretKey(publicKey1, privateKey2);
System.out.println("乙方的本地密钥:"+Base64.encodeBase64String(key2));
System.out.println("甲方的本地密钥==乙方的本地密钥:"+Base64.encodeBase64String(key1).equals(Base64.encodeBase64String(key2)));
System.out.println("================密钥对构造完毕,开始进行加密数据的传输=============");
String str = "密码交换算法";
System.out.println("原文:"+str);
System.out.println("===========使用甲方本地密钥对进行数据加密==============");
byte[] code1 = DHCoderTest.encrypt(str.getBytes(), key1);
System.out.println("加密后的数据:"+Base64.encodeBase64String(code1));
System.out.println("===========使用乙方本地密钥对数据进行解密==============");
byte[] decode1 = DHCoderTest.decrypt(code1, key2);
System.out.println("乙方解密后的数据:"+new String(decode1));
}
}
分享到:
相关推荐
简单的DH加密算法程序,采用C语言实现,权当学习资料使用; 一共7个函数,加上一个主程序实现; 不用makefile文件编写,直接一个文件编译执行
基于DH加密算法实现局域网组播加密聊天源码+apk.zip基于DH加密算法实现局域网组播加密聊天源码+apk.zip基于DH加密算法实现局域网组播加密聊天源码+apk.zip基于DH加密算法实现局域网组播加密聊天源码+apk.zip基于DH...
DH(Diffie-Hellman)加密算法是一种非对称密钥...综上所述,DH加密算法是现代密码学中的重要组成部分,为网络通信提供了安全的密钥交换手段。源码分析可以帮助我们深入理解其实现细节,从而更好地应用和改进这一技术。
c语言编写的DH算法,借鉴学习 A系统构建密钥:构建一对公私密钥Private Key1和Public Key1; A系统向B系统公布自己的公钥(Public Key1); B系统使用A公布的公钥(Public Key1)建立一对密钥:Private Key2和...
在C++中实现DH加密算法,涉及到以下几个关键知识点: 1. **数学基础**:DH算法基于离散对数问题,这涉及到模运算和大整数计算。在C++中,需要理解并使用如模幂运算( modular exponentiation)、欧拉函数(Euler's ...
DH(Diffie-Hellman)加密算法是一种非对称密钥交换协议,它允许两个通信方在不安全的网络环境中安全地协商一个共享密钥,而无需事先共享任何秘密信息。这个过程是基于数学上的大整数因子分解的困难性。C++是一种...
Java 非对称加密算法 DH 实现详解 Java 非对称加密算法 DH 实现详解是一种基于 Diffie-Hellman 密钥交换算法的非对称加密算法实现。该算法实现了密钥交换、加密和解密的过程,主要用于保证数据的安全传输。 Diffie...
java关于加密的算法demo代码(Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法) JAVA安全实现三种方式: 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法: 1.DH 2.RSA 3.ELGamal 二。...
在DH协议中,加密和解密的过程是在获取共享密钥后,使用其他对称加密算法(如AES)进行的,因为DH本身并不直接执行加密和解密操作。 **压缩包子文件的文件名称列表** 由于提供的文件名只有"DH",我们可以假设这个...
本文将详细介绍Java中常用的几种加密算法,包括但不限于DES、PBE、RSA、DH、DSA和ECC等,并提供部分示例代码以加深理解。 #### 二、基本概念 在深入讨论各种加密算法之前,我们先来了解一些基本的概念: - **加密...
加密算法是信息安全领域至关重要的组成部分,它们用于保护数据的隐私,确保信息在传输过程中的安全性。以下是21种常见的加密算法及其简要介绍: 1. **DES(Data Encryption Standard)**:一种古老的对称加密算法,...
初学了一下CryptAPI,主要是需要使用DH算法,经过几天的摸索,把CryptAPI中关于dh算法的东西简单封装了一下,程序主要通过DH算法来获取密钥,然后使用密钥来加密,加密算法可选择des,3des,rc4,加密10M的数据,循环10...
### JAVA加密算法详解 #### 一、概述 在信息技术领域,加密技术是保障信息安全的关键手段之一。本篇文章将深入探讨JAVA平台上的加密算法实现,并重点介绍单钥密码体制及其应用场景。 #### 二、单钥密码体制...
本文将深入探讨几种常见的加密算法——DES、AES、PBE、DH、RSA以及ElGamal,并结合DataServlet实例来阐述如何在实际应用中使用这些算法。 首先,DES(Data Encryption Standard)是一种对称加密算法,使用56位的...
4. **DH(Diffie-Hellman)**: Diffie-Hellman密钥交换协议,是一种非对称加密算法,用于在不安全的通道上安全地交换密钥。DHUtil.java可能包含DH密钥协商的相关方法。 5. **ECDSA(Elliptic Curve Digital ...
DH协议不提供保密性,但与公钥加密算法结合使用时,可以实现安全的数据传输。 4. **PGP(Pretty Good Privacy)**:PGP是一种广泛使用的电子邮件加密软件,它结合了公钥加密和哈希函数,以及数字签名,提供了一种...
OpenSSL是一个强大的安全套接层(SSL/TLS)和加密库,它包含了各种加密算法、实用工具以及SSL协议的支持。在软件开发中,尤其是在构建安全通信系统时,OpenSSL加密算法套件扮演着至关重要的角色。这个套件由四个关键...
常见的加密算法实现--Java语言编写,花费一个多月认真整理出来的可直接运行的源码文件。下载RAR文件后,对压缩包进行解压后,里面有详细的例子,导入IDEA或者ECLIPSE后,运行指定的Java文件,即可以直接使用。压缩包...