前言
最近公司的業務需要對部分字段加密後傳輸，學習了一些加密算法相關的知識，加密種類大致分三類：
1.對稱加密：公鑰與私鑰相同
2.非對稱加密：公鑰與私鑰不同，公鑰暴露，私鑰保密
3.哈希加密：不可逆加密，多用來判斷
下面簡單介紹下常用的非對稱性加密：DM加密
package com.jm;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
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 java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
/**
* Diffie- Hellman算法(D-H算法),密鑰一致協議。
* 是由公開密鑰密碼體制的奠基人Diffie和Hellman所提出的一種思想。
* 簡單的說就是允許兩名用 戶在公開媒體上交換信息以生成"一致"的、可以共享的密鑰。
* 換句話說,就是由甲方產出一對密鑰(公鑰、私鑰),乙方依照甲方公鑰產生乙方密鑰對(公鑰、私 鑰)。
* 以此爲基線,作爲數據傳輸保密基礎,同時雙方使用同一種對稱加密算法構建本地密鑰(SecretKey)對數據加密。
* 這樣,在互通了本地密鑰 (SecretKey)算法後,甲乙雙方公開自己的公鑰,使用對方的公鑰和剛纔產生的私鑰加密數據,
* 同時可以使用對方的公鑰和自己的私鑰對數據解密。
* 不單 單是甲乙雙方兩方,可以擴展爲多方共享數據通訊,這樣就完成了網絡交互數據的安全通訊!該算法源於中國的同餘定理——中國餘數定理。
流程分析:
1.甲方構建密鑰對兒,將公鑰公佈給乙方,將私鑰保留;雙方約定數據加密算法;乙方通過甲方公鑰構建密鑰對兒,將公鑰公佈給甲方,將私鑰保留。
2.甲方使用私鑰、乙方公鑰、約定數據加密算法構建本地密鑰,然後通過本地密鑰加密數據,發送給乙方加密後的數據;
乙方使用私鑰、甲方公鑰、約定數據加密算法構建本地密鑰,然後通過本地密鑰對數據解密。
3.乙方使用私鑰、甲方公鑰、約定數據加密算法構建本地密鑰,然後通過本地密鑰加密數據,發送給甲方加密後的數據;
甲方使用私鑰、乙方公鑰、約定數據加密算法構建本地密鑰,然後通過本地密鑰對數據解密。
*/
public class DMdemo {
public static final String ALGORITHM = "DH";
/**
* 默認密鑰字節數
*
*
* DH
* Default Keysize 1024
* Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
*
*/
private static final int KEY_SIZE = 1024;
/**
* DH加密下需要一種對稱加密算法對數據加密,這裏我們使用DES,也可以使用其他對稱加密算法。
*/
public static final String SECRET_ALGORITHM = "DES";
private static final String PUBLIC_KEY = "DHPublicKey";
private static final String PRIVATE_KEY = "DHPrivateKey";
/**
* 初始化甲方密鑰
*
* @return
* @throws Exception
*/
public static Map initKey() throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
keyPairGenerator.initialize(KEY_SIZE);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 甲方公鑰
DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
// 甲方私鑰
DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
Map keyMap = new HashMap (2);
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 初始化乙方密鑰
*
* @param key 甲方公鑰
* @return
* @throws Exception
*/
public static Map initKey(String key) throws Exception {
// 解析甲方公鑰
byte[] keyBytes = new BASE64Decoder().decodeBuffer(key);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(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 keyMap = new HashMap (2);
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 加密
*
* @param data
* 待加密數據
* @param publicKey
* 甲方公鑰
* @param privateKey
* 乙方私鑰
* @return
* @throws Exception
*/
public static String encrypt(String data, String publicKey, String privateKey) throws Exception {
// 生成本地密鑰
SecretKey secretKey = getSecretKey(publicKey, privateKey);
// 數據加密
Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
return new BASE64Encoder().encode(cipher.doFinal(data.getBytes("UTF-8")));
}
/**
* 解密
*
* @param data
* 待解密數據
* @param publicKey
* 乙方公鑰
* @param privateKey
* 乙方私鑰
* @return
* @throws Exception
*/
public static String decrypt(String data, String publicKey, String privateKey) throws Exception {
// 生成本地密鑰
SecretKey secretKey = getSecretKey(publicKey, privateKey);
// 數據解密
Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] decode_data = new BASE64Decoder().decodeBuffer(data);
return new String(cipher.doFinal(decode_data));
}
/**
* 構建密鑰
*
* @param publicKey
* 公鑰
* @param privateKey
* 私鑰
* @return
* @throws Exception
*/
private static SecretKey getSecretKey(String publicKey, String privateKey) throws Exception {
// 初始化公鑰
byte[] pubKeyBytes = new BASE64Decoder().decodeBuffer(publicKey);
KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
// 初始化私鑰
byte[] priKeyBytes = new BASE64Decoder().decodeBuffer(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);
Key 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;
}
/**
* 取得私鑰
*
* @param keyMap
* @return
* @throws Exception
*/
public static String getPrivateKey(Map keyMap) throws Exception {
Key key = (Key) keyMap.get(PRIVATE_KEY);
return new BASE64Encoder().encode(key.getEncoded());
}
/**
* 取得公鑰
*
* @param keyMap
* @return
* @throws Exception
*/
public static String getPublicKey(Map keyMap) throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY);
return new BASE64Encoder().encode(key.getEncoded());
}
public static void main(String[] args) throws Exception{
// 生成甲方密鑰對兒
Map aKeyMap = DMdemo.initKey();
String aPublicKey = DMdemo.getPublicKey(aKeyMap);
String aPrivateKey = DMdemo.getPrivateKey(aKeyMap);
System.err.println("甲方公鑰:" + aPublicKey);
System.err.println("甲方私鑰:" + aPrivateKey);
// 由甲方公鑰產生本地(乙方)密鑰對兒
Map bKeyMap = DMdemo.initKey(aPublicKey);
String bPublicKey = DMdemo.getPublicKey(bKeyMap);
String bPrivateKey = DMdemo.getPrivateKey(bKeyMap);
System.err.println("乙方公鑰:" + bPublicKey);
System.err.println("乙方私鑰:" + bPrivateKey);
String input = "鄂爾多斯市烏蘭煤炭（集團）有限責任公司溫家樑三號煤礦#C1801003133#蒙AL2928#100.0#2018-12-18 14:52:44#54.82#-100.0#不粘煤#2018-12-18 15:01:40#1.0#李四#6#\"";
System.out.println("原文: " + input);
// 由甲方公鑰,乙方私鑰構建密文
String aCode = DMdemo.encrypt(input, aPublicKey, bPrivateKey);
System.out.println("由甲方公鑰,乙方私鑰構建密文: " + aCode);
System.out.println(aCode.length());
// 由乙方公鑰,甲方私鑰解密
String aDecode = DMdemo.decrypt(aCode, bPublicKey, aPrivateKey);
System.out.println("由乙方公鑰,甲方私鑰解密: " + aDecode); System.err.println(" ===============反過來加密解密================== ");
// 由乙方公鑰,甲方私鑰構建密文
String bCode = DMdemo.encrypt(input, bPublicKey, aPrivateKey);
System.out.println("由乙方公鑰,甲方私鑰構建密文: " + bCode);
System.out.println(bCode.length());
// 由甲方公鑰,乙方私鑰解密
String bDecode = DMdemo.decrypt(bCode, aPublicKey, bPrivateKey);
System.out.println("由甲方公鑰,乙方私鑰解密: " + bDecode);
/**
* 如我代碼證實,甲乙雙方在獲得對方公鑰後可以對發送給對方的數據加密,同時也能對接收到的數據解密,達到了數據安全通信的目的!
*/
}}