經常使用加密算法之非對稱加密算法

非對稱加密算法
 
非對稱加密算法是一種密鑰的保密方法。
非對稱加密算法須要兩個密鑰：公開密鑰（publickey）和私有密鑰（privatekey）。公開密鑰與私有密鑰是一對，若是用公開密鑰對數據進行加密，只有用對應的私有密鑰才能解密；若是用私有密鑰對數據進行加密，那麼只有用對應的公開密鑰才能解密。由於加密和解密使用的是兩個不一樣的密鑰，因此這種算法叫做非對稱加密算法。 非對稱加密算法實現機密信息交換的基本過程是：甲方生成一對密鑰並將其中的一把做爲公用密鑰向其它方公開；獲得該公用密鑰的乙方使用該密鑰對機密信息進行加密後再發送給甲方；甲方再用本身保存的另外一把專用密鑰對加密後的信息進行解密。
另外一方面，甲方可使用乙方的公鑰對機密信息進行簽名後再發送給乙方；乙方再用本身的私匙對數據進行驗籤。
甲方只能用其專用密鑰解密由其公用密鑰加密後的任何信息。 非對稱加密算法的保密性比較好，它消除了最終用戶交換密鑰的須要。
非對稱密碼體制的特色：算法強度複雜、安全性依賴於算法與密鑰可是因爲其算法複雜，而使得加密解密速度沒有對稱加密解密的速度快。對稱密碼體制中只有一種密鑰，而且是非公開的，若是要解密就得讓對方知道密鑰。因此保證其安全性就是保證密鑰的安全，而非對稱密鑰體制有兩種密鑰，其中一個是公開的，這樣就能夠不須要像對稱密碼那樣傳輸對方的密鑰了。這樣安全性就大了不少。

工做原理

1.A要向B發送信息，A和B都要產生一對用於加密
非對稱加密算法
和解密的公鑰和私鑰。
2.A的私鑰保密，A的公鑰告訴B；B的私鑰保密，B的公鑰告訴A。
3.A要給B發送信息時，A用B的公鑰加密信息，由於A知道B的公鑰。
4.A將這個消息發給B（已經用B的公鑰加密消息）。
5.B收到這個消息後，B用本身的私鑰解密A的消息。其餘全部收到這個報文的人都沒法解密，由於只有B纔有B的私鑰。

 

主要應用

非對稱加密(公鑰加密)：指加密和解密使用不一樣密鑰的加密算法，也稱爲公私鑰加密。假設兩個用戶要加密交換數據，雙方交換公鑰，使用時一方用對方的公鑰加密，另外一方便可用本身的私鑰解密。若是企業中有n個用戶，企業須要生成n對密鑰，並分發n個公鑰。假設A用B的公鑰加密消息，用A的私鑰簽名，B接到消息後，首先用A的公鑰驗證簽名，確認後用本身的私鑰解密消息。因爲公鑰是能夠公開的，用戶只要保管好本身的私鑰便可，所以加密密鑰的分發將變得 十分簡單。同時，因爲每一個用戶的私鑰是惟一的，其餘用戶除了能夠經過信息發送者的公鑰來驗證信息的來源是否真實，還能夠經過數字簽名確保發送者沒法否定曾發送過該信息。非對稱加密的缺點是加解密速度要遠遠慢於對稱加密，在某些極端狀況下，甚至能比對稱加密慢上1000倍。

主要功能

非對稱加密體系不要求通訊雙方事先傳遞密鑰或有任何約定就能完成保密通訊，而且密鑰管理方便，可實現防止假冒和抵賴，所以，更適合網絡通訊中的保密通訊要求。
主要算法

RSA、Elgamal、揹包算法、Rabin、D-H、ECC（橢圓曲線加密算法）。
使用最普遍的是RSA算法，Elgamal是另外一種經常使用的非對稱加密算法

算法區別

非對稱加密算法與對稱加密算法的區別[1] 
首先，用於消息解密的密鑰值與用於消息加密的密鑰值不一樣;
其次，非對稱加密算法比對稱加密算法慢數千倍，但在保護通訊安全方面，非對稱加密算法卻具備對稱密碼難以企及的優點。
爲說明這種優點，使用對稱加密算法的例子來強調：
Alice使用密鑰K加密消息並將其發送給Bob，Bob收到加密的消息後，使用密鑰K對其解密以恢復原始消息。這裏存在一個問題，即Alice如何將用於加密消息的密鑰值發送給 Bob?答案是，Alice發送密鑰值給Bob時必須經過獨立的安全通訊信道（即沒人能監聽到該信道中的通訊）。
這種使用獨立安全信道來交換對稱加密算法密鑰的需求會帶來更多問題：
首先，有獨立的安全信道，可是安全信道的帶寬有限，不能直接用它發送原始消息。
其次，Alice和Bob不能肯定他們的密鑰值能夠保持多久而不泄露（即不被其餘人知道）以及什麼時候交換新的密鑰值
固然，這些問題不僅Alice會遇到，Bob和其餘每一個人都會遇到，他們都須要交換密鑰並處理這些密鑰管理問題（事實上，X9.17是一項DES密鑰管理ANSI標準[ANSIX9.17]）。若是Alice要給數百人發送消息，那麼事情將更麻煩，她必須使用不一樣的密鑰值來加密每條消息。例如，要給
非對稱加密算法
200我的發送通知，Alice須要加密消息200次，對每一個接收方加密一次消息。顯然，在這種狀況下，使用對稱加密算法來進行安全通訊的開銷至關大。
非對稱加密算法的主要優點就是使用兩個而不是一個密鑰值:一個密鑰值用來加密消息，另外一個密鑰值用來解密消息。這兩個密鑰值在同一個過程當中生成，稱爲密鑰對。用來加密消息的密鑰稱爲公鑰，用來解密消息的密鑰稱爲私鑰。用公鑰加密的消息只能用與之對應的私鑰來解密，私鑰除了持有者外無人知道，而公鑰卻可經過非安全管道來發送或在目錄中發佈。
Alice須要經過電子郵件給Bob發送一個機密文檔。首先，Bob使用電子郵件將本身的公鑰發送給Alice。而後Alice用Bob的公鑰對文檔加密並經過電子郵件將加密消息發送給Bob。因爲任何用Bob 的公鑰加密的消息只能用Bob的私鑰解密，所以即便窺探者知道Bob的公鑰，消息也還是安全的。Bob在收到加密消息後，用本身的私鑰進行解密從而恢復原始文檔。

說了這麼多概念性東西，都是方便你們加深理解，想要理解的更仔細能夠自行百度。

下面我會以實戰的方式實現經常使用的非對稱加密算法的加密和解密。

 

一：DH實現非對稱加密算法：
方式一：jdk的方式實現DH

      // jdk實現：
public static void jdkDH()
{
try 
{
// 1.初始化發送方密鑰
KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
senderKeyPairGenerator.initialize(512);
KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
// 發送方公鑰，發送給接收方（網絡、文件。。。）
byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();

// 2.初始化接收方密鑰
KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
DHParameterSpec dhParameterSpec = ((DHPublicKey) receiverPublicKey).getParams();
KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
receiverKeyPairGenerator.initialize(dhParameterSpec);
KeyPair receiverKeypair = receiverKeyPairGenerator.generateKeyPair();
PrivateKey receiverPrivateKey = receiverKeypair.getPrivate();
byte[] receiverPublicKeyEnc = receiverKeypair.getPublic().getEncoded();

// 3.密鑰構建
KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
receiverKeyAgreement.init(receiverPrivateKey);
receiverKeyAgreement.doPhase(receiverPublicKey, true);
SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");

KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);
KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");
senderKeyAgreement.init(senderKeyPair.getPrivate());
senderKeyAgreement.doPhase(senderPublicKey, true);
SecretKey senderDesKey = senderKeyAgreement.generateSecret("DES");
if(Objects.equals(receiverDesKey, senderDesKey))
{
System.out.println("雙方密鑰相同。");
}

// 4.加密
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, senderDesKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("bc dh encrypt:" + Base64.encodeBase64String(result));

// 5.解密
cipher.init(Cipher.DECRYPT_MODE, receiverDesKey);
result = cipher.doFinal(result);
System.out.println("bc dh decrypt:" + new String(result));

} catch (Exception e) {

e.printStackTrace();
}

}
方式二：elgamal方式實現：
// jdk實現：「私鑰解密、公鑰加密」 ， 對於：「私鑰加密、公鑰解密」有問題，由於Elgamal不支持
public static void jdkElgamal()
{
try 
{
// 加入對BouncyCastle支持  
Security.addProvider(new BouncyCastleProvider());

// 1.初始化發送方密鑰
AlgorithmParameterGenerato algorithmParameterGenerator=        AlgorithmParameterGenerator.getInstance("Elgamal");
// 初始化參數生成器
algorithmParameterGenerator.init(256);
// 生成算法參數
AlgorithmParameters algorithmParameters = algorithmParameterGenerator.generateParameters();
// 構建參數材料
DHParameterSpec dhParameterSpec = (DHParameterSpec)algorithmParameters.getParameterSpec(DHParameterSpec.class);
// 實例化密鑰生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("Elgamal");
// 初始化密鑰對生成器  
keyPairGenerator.initialize(dhParameterSpec, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 公鑰
PublicKey elGamalPublicKey = keyPair.getPublic();
// 私鑰 
PrivateKey elGamalPrivateKey = keyPair.getPrivate();
System.out.println("Public Key:" + Base64.encodeBase64String(elGamalPublicKey.getEncoded()));
System.out.println("Private Key:" + Base64.encodeBase64String(elGamalPrivateKey.getEncoded()));

// 2.私鑰解密、公鑰加密 ---- 加密
// 初始化公鑰  
        // 密鑰材料轉換
X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(elGamalPublicKey.getEncoded());
// 實例化密鑰工廠
KeyFactory keyFactory2 = KeyFactory.getInstance("Elgamal");
// 產生公鑰
PublicKey publicKey2 = keyFactory2.generatePublic(x509EncodedKeySpec2);
// 數據加密 
// Cipher cipher2 = Cipher.getInstance("Elgamal");
Cipher cipher2 = Cipher.getInstance(keyFactory2.getAlgorithm()); 
cipher2.init(Cipher.ENCRYPT_MODE, publicKey2);
byte[] result2 = cipher2.doFinal(src.getBytes());
System.out.println("私鑰加密、公鑰解密 ---- 加密:" + Base64.encodeBase64String(result2));

// 3.私鑰解密、公鑰加密 ---- 解密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(elGamalPrivateKey.getEncoded());
KeyFactory keyFactory5 = KeyFactory.getInstance("Elgamal");
PrivateKey privateKey5 = keyFactory5.generatePrivate(pkcs8EncodedKeySpec5);
// Cipher cipher5 = Cipher.getInstance("Elgamal");
Cipher cipher5 = Cipher.getInstance(keyFactory5.getAlgorithm()); 
cipher5.init(Cipher.DECRYPT_MODE, privateKey5);
byte[] result5 = cipher5.doFinal(result2);
System.out.println("Elgamal 私鑰加密、公鑰解密 ---- 解密:" + new String(result5));

 

/*
// 私鑰加密、公鑰解密: 有問題
// 4.私鑰加密、公鑰解密 ---- 加密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(elGamalPrivateKey.getEncoded());
KeyFactory keyFactory = KeyFactory.getInstance("Elgamal");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("Elgamal");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("私鑰加密、公鑰解密 ---- 加密:" + Base64.encodeBase64String(result));

// 5.私鑰加密、公鑰解密 ---- 解密
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(elGamalPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("Elgamal");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher = Cipher.getInstance("Elgamal");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
result = cipher.doFinal(result);
System.out.println("Elgamal 私鑰加密、公鑰解密 ---- 解密:" + new String(result));
*/

} catch (Exception e) {

e.printStackTrace();
}

}

 

方式二：

//非對稱密鑰算法
public static final String KEY_ALGORITHM="ElGamal";

/**
* 密鑰長度，DH算法的默認密鑰長度是1024
* 密鑰長度必須是8的倍數，在160到16384位之間
* */
private static final int KEY_SIZE=256;
//公鑰
private static final String PUBLIC_KEY="ElGamalPublicKey";

//私鑰
private static final String PRIVATE_KEY="ElGamalPrivateKey";

/**
* 初始化密鑰對
* @return Map 甲方密鑰的Map
* */
public static Map<String,Object> initKey() throws Exception{
//加入對BouncyCastle支持
Security.addProvider(new BouncyCastleProvider());
AlgorithmParameterGenerator apg=AlgorithmParameterGenerator.getInstance(KEY_ALGORITHM);
//初始化參數生成器
apg.init(KEY_SIZE);
//生成算法參數
AlgorithmParameters params=apg.generateParameters();
//構建參數材料
DHParameterSpec elParams=(DHParameterSpec)params.getParameterSpec(DHParameterSpec.class);

//實例化密鑰生成器
KeyPairGenerator kpg=KeyPairGenerator.getInstance(KEY_ALGORITHM) ;

//初始化密鑰對生成器
kpg.initialize(elParams,new SecureRandom());

KeyPair keyPair=kpg.generateKeyPair();
//甲方公鑰
PublicKey publicKey= keyPair.getPublic();
//甲方私鑰
PrivateKey privateKey= 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[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{

//實例化密鑰工廠
KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公鑰
//密鑰材料轉換
X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
//產生公鑰
PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);

//數據加密
Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, pubKey);
return cipher.doFinal(data);
}
/**
* 私鑰解密
* @param data 待解密數據
* @param key 密鑰
* @return byte[] 解密數據
* */
public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
//取得私鑰
PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//生成私鑰
PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
//數據解密
Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}

/**
* 取得私鑰
* @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();
}
/**
* @param args
* @throws Exception 
*/
public static void main(String[] args) throws Exception {
//初始化密鑰
//生成密鑰對
Map<String,Object> keyMap=ElGamalTest2.initKey();
//公鑰
byte[] publicKey=ElGamalTest2.getPublicKey(keyMap);

//私鑰
byte[] privateKey=ElGamalTest2.getPrivateKey(keyMap);
System.out.println("公鑰：/n"+Base64.encodeBase64String(publicKey));
System.out.println("私鑰：/n"+Base64.encodeBase64String(privateKey));

System.out.println("================密鑰對構造完畢,甲方將公鑰公佈給乙方，開始進行加密數據的傳輸=============");
String str="ElGamal密碼交換算法";
System.out.println("/n===========甲方向乙方發送加密數據==============");
System.out.println("原文:"+str);

//乙方使用公鑰對數據進行加密
byte[] code2=ElGamalTest2.encryptByPublicKey(str.getBytes(), publicKey);
System.out.println("===========乙方使用公鑰對數據進行加密==============");
System.out.println("加密後的數據："+Base64.encodeBase64String(code2));

//甲方使用私鑰對數據進行解密
byte[] decode2=ElGamalTest2.decryptByPrivateKey(code2, privateKey);

System.out.println("甲方解密後的數據："+new String(decode2));
}

 

方式三：RSA實現非對稱加密算法：
RSA實現非對稱也有倆種方式，具體的實現和區別見代碼註釋：
       方式一：jdk實現

       // jdk實現：私鑰加密、公鑰解密： 併發時間測試
public static void RSA()
{
try 
{
long startTimes = System.currentTimeMillis();

// 1.初始化發送方密鑰
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(512);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
final RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
System.out.println("Public Key:" + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
System.out.println("Private Key:" + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));

 

// 2.公鑰加密、私鑰解密 ---- 加密
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
result = cipher.doFinal(src.getBytes());
System.out.println("公鑰加密、私鑰解密 ---- 加密:" + Base64.encodeBase64String(result));

long endEncryptTime = System.currentTimeMillis();
System.out.println("公鑰加密、私鑰解密 ---- 加密1個時間(單位毫秒):" + (endEncryptTime - startTimes));

int decryptTimes = 200000;  // 併發解密的個數
//建立一個可重用固定線程數的線程池
        ExecutorService pool =  Executors.newCachedThreadPool(); // Executors.newFixedThreadPool(1000);
        
for(int i=0; i<decryptTimes;i++)
{
pool.execute(new Thread(new Runnable() {

@Override
public void run() {
try {
// 3.私鑰解密、公鑰加密 ---- 解密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec2 = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory2 = KeyFactory.getInstance("RSA");

PrivateKey privateKey2 = keyFactory2.generatePrivate(pkcs8EncodedKeySpec2);
Cipher cipher2 = Cipher.getInstance("RSA");
cipher2.init(Cipher.DECRYPT_MODE, privateKey2);
byte[] result2 = cipher2.doFinal(result);
// System.out.println("公鑰加密、私鑰解密 ---- 解密:" + new String(result2));
} catch (Exception e) {
e.printStackTrace();
}
}
}));
  
}

pool.shutdown();

while (true) {  
            if (pool.isTerminated()) {  
                System.out.println("結束了！"); 
                long endDencryptTime = System.currentTimeMillis() ;
                long totalTimes = (endDencryptTime - endEncryptTime) / 1000;
                System.out.println("公鑰加密、私鑰解密 ---- 併發：" + decryptTimes + "個解密時間(單位秒):" + totalTimes);
                break;  
            }  
            Thread.sleep(200);  
        }

} catch (Exception e) {

e.printStackTrace();
}

}

 

方式二：

// jdk實現：
public static void jdkRSA()
{
try 
{
// 1.初始化發送方密鑰
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(512);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
System.out.println("Public Key:" + Base64.encodeBase64String(rsaPublicKey.getEncoded()));
System.out.println("Private Key:" + Base64.encodeBase64String(rsaPrivateKey.getEncoded()));

// 2.私鑰加密、公鑰解密 ---- 加密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(src.getBytes());
System.out.println("私鑰加密、公鑰解密 ---- 加密:" + Base64.encodeBase64String(result));

// 3.私鑰加密、公鑰解密 ---- 解密
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
result = cipher.doFinal(result);
System.out.println("私鑰加密、公鑰解密 ---- 解密:" + new String(result));

 

// 4.公鑰加密、私鑰解密 ---- 加密
X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
KeyFactory keyFactory2 = KeyFactory.getInstance("RSA");
PublicKey publicKey2 = keyFactory2.generatePublic(x509EncodedKeySpec2);
Cipher cipher2 = Cipher.getInstance("RSA");
cipher2.init(Cipher.ENCRYPT_MODE, publicKey2);
byte[] result2 = cipher2.doFinal(src.getBytes());
System.out.println("公鑰加密、私鑰解密 ---- 加密:" + Base64.encodeBase64String(result2));

// 5.私鑰解密、公鑰加密 ---- 解密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory5 = KeyFactory.getInstance("RSA");
PrivateKey privateKey5 = keyFactory5.generatePrivate(pkcs8EncodedKeySpec5);
Cipher cipher5 = Cipher.getInstance("RSA");
cipher5.init(Cipher.DECRYPT_MODE, privateKey5);
byte[] result5 = cipher5.doFinal(result2);
System.out.println("公鑰加密、私鑰解密 ---- 解密:" + new String(result5));

} catch (Exception e) {

e.printStackTrace();
}

}

 

好了，對稱加密算法就總結到這裏了，在下一篇中，我將會總結經常使用的對稱加密算法。

原文出處：https://blog.csdn.net/ljx1400052550/article/details/79587133