Java加密技术（五）——非对称加密算法的由来DH
Java非对称加密算法dh
接下来我们分析DH加密算法，一种适基于密钥一致协议的加密算法。
DH
Diffie-Hellman算法(D-H算法)，密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说，就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密。这样，在互通了本地密钥（SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！该算法源于中国的同余定理——中国馀数定理。
流程分析：
1.甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。
2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。
通过java代码实现如下：Coder类见Java加密技术（一）
Java代码收藏代码
importjava.security.Key;
importjava.security.KeyFactory;
importjava.security.KeyPair;
importjava.security.KeyPairGenerator;
importjava.security.PublicKey;
importjava.security.spec.PKCS8EncodedKeySpec;
importjava.security.spec.X509EncodedKeySpec;
importjava.util.HashMap;
importjava.util.Map;
importjavax.crypto.Cipher;
importjavax.crypto.KeyAgreement;
importjavax.crypto.SecretKey;
importjavax.crypto.interfaces.DHPrivateKey;
importjavax.crypto.interfaces.DHPublicKey;
importjavax.crypto.spec.DHParameterSpec;
/**
*DH安全编码组件
*
*@author梁栋
*@version1.0
*@since1.0
*/
publicabstractclassDHCoderextendsCoder{
publicstaticfinalStringALGORITHM="DH";
/**
*默认密钥字节数
*
*<pre>
*DH
*DefaultKeysize1024
*Keysizemustbeamultipleof64,rangingfrom512to1024(inclusive).
*</pre>
*/
privatestaticfinalintKEY_SIZE=1024;
/**
*DH加密下需要一种对称加密算法对数据加密，这里我们使用DES，也可以使用其他对称加密算法。
*/
publicstaticfinalStringSECRET_ALGORITHM="DES";
privatestaticfinalStringPUBLIC_KEY="DHPublicKey";
privatestaticfinalStringPRIVATE_KEY="DHPrivateKey";
/**
*初始化甲方密钥
*
*@return
*@throwsException
*/
publicstaticMap<String,Object>initKey()throwsException{
KeyPairGeneratorkeyPairGenerator=KeyPairGenerator
.getInstance(ALGORITHM);
keyPairGenerator.initialize(KEY_SIZE);
KeyPairkeyPair=keyPairGenerator.generateKeyPair();
//甲方公钥
DHPublicKeypublicKey=(DHPublicKey)keyPair.getPublic();
//甲方私钥
DHPrivateKeyprivateKey=(DHPrivateKey)keyPair.getPrivate();
Map<String,Object>keyMap=newHashMap<String,Object>(2);
keyMap.put(PUBLIC_KEY,publicKey);
keyMap.put(PRIVATE_KEY,privateKey);
returnkeyMap;
}
/**
*初始化乙方密钥
*
*@paramkey
*甲方公钥
*@return
*@throwsException
*/
publicstaticMap<String,Object>initKey(Stringkey)throwsException{
//解析甲方公钥
byte[]keyBytes=decryptBASE64(key);
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(ALGORITHM);
PublicKeypubKey=keyFactory.generatePublic(x509KeySpec);
//由甲方公钥构建乙方密钥
DHParameterSpecdhParamSpec=((DHPublicKey)pubKey).getParams();
KeyPairGeneratorkeyPairGenerator=KeyPairGenerator
.getInstance(keyFactory.getAlgorithm());
keyPairGenerator.initialize(dhParamSpec);
KeyPairkeyPair=keyPairGenerator.generateKeyPair();
//乙方公钥
DHPublicKeypublicKey=(DHPublicKey)keyPair.getPublic();
//乙方私钥
DHPrivateKeyprivateKey=(DHPrivateKey)keyPair.getPrivate();
Map<String,Object>keyMap=newHashMap<String,Object>(2);
keyMap.put(PUBLIC_KEY,publicKey);
keyMap.put(PRIVATE_KEY,privateKey);
returnkeyMap;
}
/**
*加密<br>
*
*@paramdata
*待加密数据
*@parampublicKey
*甲方公钥
*@paramprivateKey
*乙方私钥
*@return
*@throwsException
*/
publicstaticbyte[]encrypt(byte[]data,StringpublicKey,
StringprivateKey)throwsException{
//生成本地密钥
SecretKeysecretKey=getSecretKey(publicKey,privateKey);
//数据加密
Ciphercipher=Cipher.getInstance(secretKey.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,secretKey);
returncipher.doFinal(data);
}
/**
*解密<br>
*
*@paramdata
*待解密数据
*@parampublicKey
*乙方公钥
*@paramprivateKey
*乙方私钥
*@return
*@throwsException
*/
publicstaticbyte[]decrypt(byte[]data,StringpublicKey,
StringprivateKey)throwsException{
//生成本地密钥
SecretKeysecretKey=getSecretKey(publicKey,privateKey);
//数据解密
Ciphercipher=Cipher.getInstance(secretKey.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,secretKey);
returncipher.doFinal(data);
}
/**
*构建密钥
*
*@parampublicKey
*公钥
*@paramprivateKey
*私钥
*@return
*@throwsException
*/
privatestaticSecretKeygetSecretKey(StringpublicKey,StringprivateKey)
throwsException{
//初始化公钥
byte[]pubKeyBytes=decryptBASE64(publicKey);
KeyFactorykeyFactory=KeyFactory.getInstance(ALGORITHM);
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(pubKeyBytes);
PublicKeypubKey=keyFactory.generatePublic(x509KeySpec);
//初始化私钥
byte[]priKeyBytes=decryptBASE64(privateKey);
PKCS8EncodedKeySpecpkcs8KeySpec=newPKCS8EncodedKeySpec(priKeyBytes);
KeypriKey=keyFactory.generatePrivate(pkcs8KeySpec);
KeyAgreementkeyAgree=KeyAgreement.getInstance(keyFactory
.getAlgorithm());
keyAgree.init(priKey);
keyAgree.doPhase(pubKey,true);
//生成本地密钥
SecretKeysecretKey=keyAgree.generateSecret(SECRET_ALGORITHM);
returnsecretKey;
}
/**
*取得私钥
*
*@paramkeyMap
*@return
*@throwsException
*/
publicstaticStringgetPrivateKey(Map<String,Object>keyMap)
throwsException{
Keykey=(Key)keyMap.get(PRIVATE_KEY);
returnencryptBASE64(key.getEncoded());
}
/**
*取得公钥
*
*@paramkeyMap
*@return
*@throwsException
*/
publicstaticStringgetPublicKey(Map<String,Object>keyMap)
throwsException{
Keykey=(Key)keyMap.get(PUBLIC_KEY);
returnencryptBASE64(key.getEncoded());
}
}
再给出一个测试类：
Java代码收藏代码
importstaticorg.junit.Assert.*;
importjava.util.Map;
importorg.junit.Test;
/**
*
*@author梁栋
*@version1.0
*@since1.0
*/
publicclassDHCoderTest{
@Test
publicvoidtest()throwsException{
//生成甲方密钥对儿
Map<String,Object>aKeyMap=DHCoder.initKey();
StringaPublicKey=DHCoder.getPublicKey(aKeyMap);
StringaPrivateKey=DHCoder.getPrivateKey(aKeyMap);
System.err.println("甲方公钥:\r"+aPublicKey);
System.err.println("甲方私钥:\r"+aPrivateKey);
//由甲方公钥产生本地密钥对儿
Map<String,Object>bKeyMap=DHCoder.initKey(aPublicKey);
StringbPublicKey=DHCoder.getPublicKey(bKeyMap);
StringbPrivateKey=DHCoder.getPrivateKey(bKeyMap);
System.err.println("乙方公钥:\r"+bPublicKey);
System.err.println("乙方私钥:\r"+bPrivateKey);
StringaInput="abc";
System.err.println("原文:"+aInput);
//由甲方公钥，乙方私钥构建密文
byte[]aCode=DHCoder.encrypt(aInput.getBytes(),aPublicKey,
bPrivateKey);
//由乙方公钥，甲方私钥解密
byte[]aDecode=DHCoder.decrypt(aCode,bPublicKey,aPrivateKey);
StringaOutput=(newString(aDecode));
System.err.println("解密:"+aOutput);
assertEquals(aInput,aOutput);
System.err.println("===============反过来加密解密==================");
StringbInput="def";
System.err.println("原文:"+bInput);
//由乙方公钥，甲方私钥构建密文
byte[]bCode=DHCoder.encrypt(bInput.getBytes(),bPublicKey,
aPrivateKey);
//由甲方公钥，乙方私钥解密
byte[]bDecode=DHCoder.decrypt(bCode,aPublicKey,bPrivateKey);
StringbOutput=(newString(bDecode));
System.err.println("解密:"+bOutput);
assertEquals(bInput,bOutput);
}
}
控制台输出：
Console代码收藏代码
甲方公钥:
MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz
W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG
kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko
Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ==
甲方私钥:
MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX
rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD
TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR
eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos=
乙方公钥:
MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz
W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG
kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr
dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ==
乙方私钥:
MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX
rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD
TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp
2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd
原文:abc
解密:abc
===============反过来加密解密==================
原文:def
解密:def
如我所言，甲乙双方在获得对方公钥后可以对发送给对方的数据加密，同时也能对接收到的数据解密，达到了数据安全通信的目的！