常见的对称式加密与非对称式加密算法

1.概述

        对称式加密：对称加密算法就是传统的用一个密码进行加密和解密，通信发送方使用这种算法加密数据,接收方也用同样的算法解密数据. 因此对称式加密本身不是安全的。从程序的角度看，所谓加密，就是这样一个函数：

        它接收密码和明文，然后输出密文： secret = encrypt(key, message); 而解密则相反，它接收密码和密文，然后输出明文： plain = decrypt(key, secret);

        常见的对称式加密算法：

算法	秘钥长度	工作模式	填充模式
AES	56/64	ECB/CBC/PCBC/CTR/...	NoPadding/PKCS5Padding/...
DES	128/192/256	ECB/CBC/PCBC/CTR/..	NoPadding/PKCS5Padding/PKCS7Padding/...
IDEA	128	ECB	PKCS5Padding/PKCS7Padding/...

        密钥长度直接决定加密强度，而工作模式和填充模式可以看成是对称加密算法的参数和格式选择。Java标准库提供的算法实现并不包括所有的工作模式和所有填充模式，但是通常我们只需要挑选常用的使用就可以了。

        非对称式加密：加密和解密使用的不是相同的密钥，只有同一个公钥-私钥对才能正常加解密，例如：小明要加密一个文件发送给小红，他应该首先向小红索取她的公钥，然后，他用小红的公钥加密，把加密文件发送给小红，此文件只能由小红的私钥解开，因为小红的私钥在她自己手里，所以，除了小红，没有任何人能解开此文件。

        非对称加密的优点：对称加密需要协商密钥，而非对称加密可以安全地公开各自的公钥，在N个人之间通信的时候：使用非对称加密只需要N个密钥对，每个人只管理自己的密钥对。而使用对称加密需要则需要N*(N-1)/2个密钥，因此每个人需要管理N-1个密钥，密钥管理难度大，而且非常容易泄漏。

        非对称加密的缺点：运算速度非常慢，比对称加密要慢很多

        非对称加密的典型算法就是RSA算法，它是由Ron Rivest，Adi Shamir，Leonard Adleman这三个人一起发明的，所以用他们三个人的姓氏首字母缩写表示。

2.使用AES加密

1.根据算法名称/工作模式/填充模式获取Cipher实例；

2 根据算法名称初始化一个SecretKey实例，密钥必须是指定长度；

3 使用SerectKey初始化Cipher实例，并设置加密或解密模式；

4 传入明文或密文，获得密文或明文。

public class AES_Test {
	public static void main(String[] args) throws Exception{
		String message = "HelloWorld";
		System.out.println("原始内容:" +message);
		
		//128位秘钥=16 bytes key：
		byte[] key = "1234567996xxyabc".getBytes();
		
		//加密：
		byte[] data = message.getBytes();
		byte[] encrypted = encrypt(key,data);
		System.out.println("加密结果: "+Base64.getEncoder().encodeToString(encrypted));
		
		//解密:
		byte[] decrypted = decrypt(key,encrypted);
		System.out.println("解密结果: "+new String(decrypted));
		
	}
	//加密：
	public static byte[] encrypt(byte[] key,byte[] input) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		//创建密码对象,需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		
		//根据key的字节内容，"恢复"密码对象
		SecretKey keySpec = new SecretKeySpec(key, "AES");
		//初始化秘钥,设置加密模式ENCRYPT_MODE
		cipher.init(cipher.ENCRYPT_MODE, keySpec);
		//根据原始内容(字节)，进行加密
		return cipher.doFinal(input);		
	}
	//解密：
	public static byte[] decrypt(byte[] key,byte[] input) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
		//创建密码对象,需要传入算法/工作模式/填充模式
		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
		
		//根据key的字节内容，"恢复"密码对象
		SecretKey keySpec = new SecretKeySpec(key, "AES");
		//初始化秘钥,设置解密模式DECRYPT_MODE
		cipher.init(cipher.DECRYPT_MODE, keySpec);
		//根据原始内容(字节)，进行解密
		return cipher.doFinal(input);		
	}
}

输出结果：

原始内容:HelloWorld
加密结果: z0cr9rJRvwNu9V7D6EOlzw==
解密结果: HelloWorld

3.RSA加密算法

import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;

// RSA
public class Main {
	public static void main(String[] args) throws Exception {
		// 明文:
		byte[] plain = "Hello, encrypt use RSA".getBytes("UTF-8");

		// 创建公钥／私钥对:
		Human alice = new Human("Alice");

		// 用Alice的公钥加密:
		// 获取Alice的公钥，并输出
		byte[] pk = alice.getPublicKey();
		System.out.println(String.format("public key(公钥): %x", new BigInteger(1, pk)));

		// 使用公钥加密
		byte[] encrypted = alice.encrypt(plain);
		System.out.println(String.format("encrypted(加密): %x", new BigInteger(1, encrypted)));

		// 用Alice的私钥解密:
		// 获取Alice的私钥，并输出
		byte[] sk = alice.getPrivateKey();
		System.out.println(String.format("private key(私钥): %x", new BigInteger(1, sk)));

		// 使用私钥解密
		byte[] decrypted = alice.decrypt(encrypted);
		System.out.println("decrypted(解密): " + new String(decrypted, "UTF-8"));
	}
}

// 用户类
class Human {
	// 姓名
	String name;

	// 私钥:
	PrivateKey sk;

	// 公钥:
	PublicKey pk;

	// 构造方法
	public Human(String name) throws GeneralSecurityException {
		// 初始化姓名
		this.name = name;

		// 生成公钥／私钥对:
		KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA");
		kpGen.initialize(1024);
		KeyPair kp = kpGen.generateKeyPair();

		this.sk = kp.getPrivate();
		this.pk = kp.getPublic();
	}

	// 把私钥导出为字节
	public byte[] getPrivateKey() {
		return this.sk.getEncoded();
	}

	// 把公钥导出为字节
	public byte[] getPublicKey() {
		return this.pk.getEncoded();
	}

	// 用公钥加密:
	public byte[] encrypt(byte[] message) throws GeneralSecurityException {
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(Cipher.ENCRYPT_MODE, this.pk); // 使用公钥进行初始化
		return cipher.doFinal(message);
	}

	// 用私钥解密:
	public byte[] decrypt(byte[] input) throws GeneralSecurityException {
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(Cipher.DECRYPT_MODE, this.sk); // 使用私钥进行初始化
		return cipher.doFinal(input);
	}
}

        RSA算法的密钥有256/512/1024/2048/4096等不同的长度。长度越长，密码强度越大，当然计算速度也越慢。

4.总结：

        1.加密和解密过程不同 ：对称加密过程和解密过程使用的同一个密钥，加密过程相当于用原文+密钥可以传输出密文，同时解密过程用密文-密钥可以推导出原文。但非对称加密采用了两个密钥，一般使用公钥进行加密，使用私钥进行解密。

         2.加密解密速度不同 : 对称加密解密的速度比较快，适合数据比较长时的使用。非对称加密和解密花费的时间长、速度相对较慢，只适合对少量数据的使用。  

        3.传输的安全性不同 : 对称加密的过程中无法确保密钥被安全传递，密文在传输过程中是可能被第三方截获的，如果密码本也被第三方截获，则传输的密码信息将被第三方破获，安全性相对较低。  非对称加密算法中私钥是基于不同的算法生成不同的随机数，私钥通过一定的加密算法推导出公钥，但私钥到公钥的推导过程是单向的，也就是说公钥无法反推导出私钥。所以安全性较高。