经常使用加密算法之非对称加密算法

非对称加密算法
 
非对称加密算法是一种密钥的保密方法。
非对称加密算法须要两个密钥：公开密钥（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