前言
加密数据的方法可以分为两种：加密和解密都使用相同密钥的“共享密钥加密”和分别使用不同密钥的“公开密钥加密”。
本文将以图文的形式讲解这两种加密的机制以及相关问题，挑选使用最为广泛两种加密算法，用JAVA将其实现，欢迎各位感兴趣的开发者阅读本文。
共享密钥加密
概念
共享密钥加密是加密和解密都是用相同密钥的一种加密方式，由于使用的密钥相同，所以这种算法也被称为“对称加密”，实现共享加密的算法有：「AES」、「DES」、「动态口令」等，其中AES的应用最为广泛。
处理流程图解
例如，A准备通过互联网向B发送数据
由于有被窃听的风险，所以需要把数据加密后再发送。
- A使用密钥加密数据，并将密文发送给B。
- B收到秘文后，使用相同的密钥对其进行解密。这样B就取得了原本的数据。此时的数据已经是加密好的了，就不需要担心第三者窃取数据了，因为它没有密钥解开此密文。
可能产生的问题
如图所示，B接收A发送的密文时，密文可能已经被X窃听了。
- 此时，B不知道加密时使用的是什么密钥。
- A需要通过某种手段将密钥交给B。和密文一样，A又在互联网上向B发送了密钥。
- B使用收到的密钥对密文进行解密，但是该密钥也有可能会被X窃听，这样以来X也可以使用密钥对密文进行解密了。
❝使用共享密钥加密时，如果接收方不知道密钥是什么，发送方就要通过互联网发送密钥给接收方，此时密钥可能会被第三者监听，这就是共享密钥加密最大问题的所在。 ❞
解决方案
如上所述，共享密钥加密存在密钥送达问题，想要解决这个问题，我们可以使用“密钥交换协议”和“公开密钥加密”两种方法。
恩尼格玛密码机
第二次世界大战中，德军所用的”恩尼格玛密码机“使用的加密方式就是共享密钥加密，我们熟知的英国数学家「艾伦·图灵」就破解了这个密码机生成的密文，在二战中为英国做了很多的贡献，比如著名的“诺曼底登陆”事件，昨晚看了一部电影《模仿游戏》，该电影讲了图灵的一生，其中就包括了破解恩尼格玛密码机这一部分，挺好的一部电影，感兴趣的朋友可以去看看。
JAVA实现AES加密
我们用Java实现下AES加密。
- 创建AESUtils文件,编写AES加密工具类
package com.lk.util;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.SecureRandom;
public class AESUtils {
/**
* 密钥长度: 128, 192 or 256
*/
private static final int KEY_SIZE = 128;
/**
* 加密/解密算法名称
*/
private static final String ALGORITHM = "AES";
/**
* 随机数生成器（RNG）算法名称
*/
private static final String RNG_ALGORITHM = "SHA1PRNG";
/**
* 生成密钥对象
* @param key byte[] 类型参数
* @return AES密钥对象
*/
private static SecretKey generateKey(byte[] key) throws Exception {
// 创建安全随机数生成器
SecureRandom random = SecureRandom.getInstance(RNG_ALGORITHM);
// 设置 密钥key的字节数组 作为安全随机数生成器的种子
random.setSeed(key);
// 创建 AES算法生成器
KeyGenerator gen = KeyGenerator.getInstance(ALGORITHM);
// 初始化算法生成器
gen.init(KEY_SIZE, random);
// 生成 AES密钥对象
return gen.generateKey();
}
/**
* 数据加密: 明文 -> 密文
*/
public static byte[] encrypt(byte[] plainBytes, byte[] key) throws Exception {
// 生成密钥对象
SecretKey secKey = generateKey(key);
// 获取 AES 密码器
Cipher cipher = Cipher.getInstance(ALGORITHM);
// 初始化密码器（加密模型）
cipher.init(Cipher.ENCRYPT_MODE, secKey);
// 加密数据, 返回密文
return cipher.doFinal(plainBytes);
}
/**
* 数据解密: 密文 -> 明文
*/
public static byte[] decrypt(byte[] cipherBytes, byte[] key) throws Exception {
// 生成密钥对象
SecretKey secKey = generateKey(key);
// 获取 AES 密码器
Cipher cipher = Cipher.getInstance(ALGORITHM);
// 初始化密码器（解密模型）
cipher.init(Cipher.DECRYPT_MODE, secKey);
// 解密数据, 返回明文
return cipher.doFinal(cipherBytes);
}
/**
* byte数组转16进制
*
* @param bytes byte数组
* @return 返回16进制字符串
*/
public static String bytesToHex(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (byte aByte : bytes) {
String hex = Integer.toHexString(aByte & 0xFF);
if (hex.length() < 2) {
sb.append(0);
}
sb.append(hex);
}
return sb.toString();
}
/**
* 16进制转byte
* @param inHex 16进制字符串
* @return byte
*/
public static byte hexToByte(String inHex) {
return (byte) Integer.parseInt(inHex, 16);
}
/**
* 16进制转byte数组
* @param inHex 16进制字符串
* @return byte数组
*/
public static byte[] hexToByteArray(String inHex) {
int hexlen = inHex.length();
byte[] result;
if (hexlen % 2 == 1) {
//奇数
hexlen ;
result = new byte[(hexlen / 2)];
inHex = "0" inHex;
} else {
//偶数
result = new byte[(hexlen / 2)];
}
int j = 0;
for (int i = 0; i < hexlen; i = 2) {
result[j] = hexToByte(inHex.substring(i, i 2));
j ;
}
return result;
}
/**
* 加密文件: 明文输入 -> 密文输出
*/
public static void encryptFile(File plainIn, File cipherOut, byte[] key) throws Exception {
aesFile(plainIn, cipherOut, key, true);
}
/**
* 解密文件: 密文输入 -> 明文输出
*/
public static void decryptFile(File cipherIn, File plainOut, byte[] key) throws Exception {
aesFile(plainOut, cipherIn, key, false);
}
/**
* AES 加密/解密文件
*/
private static void aesFile(File plainFile, File cipherFile, byte[] key, boolean isEncrypt) throws Exception {
// 获取 AES 密码器
Cipher cipher = Cipher.getInstance(ALGORITHM);
// 生成密钥对象
SecretKey secKey = generateKey(key);
// 初始化密码器
cipher.init(isEncrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, secKey);
// 加密/解密数据
InputStream in = null;
OutputStream out = null;
try {
if (isEncrypt) {
// 加密: 明文文件为输入, 密文文件为输出
in = new FileInputStream(plainFile);
out = new FileOutputStream(cipherFile);
} else {
// 解密: 密文文件为输入, 明文文件为输出
in = new FileInputStream(cipherFile);
out = new FileOutputStream(plainFile);
}
byte[] buf = new byte[1024];
int len = -1;
// 循环读取数据 加密/解密
while ((len = in.read(buf)) != -1) {
out.write(cipher.update(buf, 0, len));
}
out.write(cipher.doFinal()); // 最后需要收尾
out.flush();
} finally {
close(in);
close(out);
}
}
private static void close(Closeable c) {
if (c != null) {
try {
c.close();
} catch (IOException e) {
// nothing
}
}
}
}
- 在main函数中测试工具类
public static void main(String[] args) throws Exception {
// 原文内容
String content = "你好，我是要发送的数据";
// AES加密/解密用的原始密码
String key = "MagicalProgrammer";
// 加密数据, 返回密文
byte[] cipherBytes = AESUtils.encrypt(content.getBytes(), key.getBytes());
// byte[]转16进制
String cipherString = AESUtils.bytesToHex(cipherBytes);
// 输出加密后的16进制密文
System.out.println("加密后的密文为: ");
System.out.println(cipherString);
// 解密数据, 返回明文
byte[] plainBytes = AESUtils.decrypt(AESUtils.hexToByteArray(cipherString), key.getBytes());
// 输出解密后的明文
System.out.println("解密后结果为: ");
System.out.println(new String(plainBytes));
}
公开密钥加密
概念
公开密钥加密是加密和解密使用不同密钥的一种加密方法。由于使用的密钥不同，所以这种算法也被称为“非对称加密”。加密用的密钥叫做“公开密钥”，解密用的叫做“私有密钥”。
处理流程图解
如图所示，A通过互联网向B发送数据。
- 首先，由接收方B来生成公开密钥和私有密钥。
- 然后，将公开密钥发送给B。
- A使用B发来的公开密钥加密数据
- A将密文发送给B，B再使用私有密钥对密文进行解密。这样，B就得到了原本的数据。
- 公开密钥和密文都是通过互联网传输的，因此可能被X窃听。但是，使用公开密钥无法解密密文，因此X也无法得到原本的数据。
❝实现公开密钥加密的算法有「RSA算法」、「椭圆曲线加密算法」等，其中使用最为广泛的是RSA算法。 ❞
方便多人传输数据
在和多人传输数据时，使用公开密钥加密十分方便。
例如，B预先准备好了公开密钥和私有密钥，
公开密钥是不怕被人知道的，所以B可以把公开密钥发布在网上。
此时，有许多人都想向B发送数据。
- 首先，想发送数据的人需要从王山取得B发布的公开密钥。
- 然后，用获取到的公开密钥加密要发送的数据。
- 最后，把密文发送给B
- B用私有密钥对收到的密文进行解密，取得原本的数据。这种情况就不需要为每个发送对象都准备对应的密钥了。需要保密的私有密钥由接收方保管，所以安全性也更高。
❝如果使用共享密钥加密，密钥的需求数量会随着发送人数的增多而急剧增多。例如，有2个人相互发送数据，需要2个密钥，但是5个人相互发送数据就需要10个密钥，100人就需要4950个。假设有n个人需要相互发送数据，那么需要的密钥数量就为「n(n-1)/2」。 ❞
中间人攻击
公开密钥加密存在公开密钥可靠性的问题，B在给A发送公开密钥时，可能会被第三者拦截到这个公开密钥，第三者拿到公开密钥后，保存到本地，自己重新生成一个新的公开密钥发送给A，A使用第三者的公开密钥加密数据后，将数据发送给A时，第三者劫持A发送的数据，用自己的私有密钥解密数据，此时第三者就拿到了B要发送的数据，然后第三者用B的公开密钥再次对解密的数据进行加密，然后发送给B，B用自己的私有密钥正常解开了B发送的数据，整个发送与接收的过程中，没有发生任何问题，因此A也察觉不到数据已经泄漏，这种通过中途替换公开密钥来窃听数据的攻击方法就叫做「中间人攻击」。
我们回到B生成公开密钥和私有密钥的时候，我们用PB表示公开密钥，SB表示私有密钥。
X想要窃听A发送给B的数据，于是他准备了公开密钥PX和私有密钥SX。
- 在B把公开密钥PB发送给A的时候
- X把公开密钥PB替换成自己的PX
- 于是公开密钥Px传到了A那里，由于公开密钥无法显示自己是由谁生成的，所以A不会发现自己收到的公开密钥已经被人替换。
- A使用公开密钥PX对数据加密
- 当A把想要给B的密文发送出去后，X接收了这个密文。
- 这个密文由X生成的公开密钥PX加密而成，所以X可以用自己的私有密钥SX对密文进行解密。
- X用B生成的公开密钥PB加密数据
- X把密文发送给B，这个密文由B发出的公开密钥PB加密而成，所以B可以用自己的私有密钥SB来解密，从收到密文到解密密文都没发生任何问题，因此B也不可能意识到自己已经被窃听。
解决方案
公开密钥的可靠性会出现问题，因此A无法判断收到的公开密钥是否来自B，要想解决这一问题，就要用到“数字证书。
公开密钥加密还有一个问题，加密和解密都比较耗时。所以这种方式不适用于持续发送零碎数据的情况，要想解决这一问题，就要用到“混合加密”。
实现难点
要想找到实现公开密钥加密的算法并不容易。考虑到加密所需的计算流程，算法必 须满足如下条件。
- 可以使用某个数值对数据进行加密
- 使用另一个数值对加密数据进行计算就可以让数据恢复原样。
- 无法从一种密钥推算出另一种密钥。
稍微思考一下便知道，想要找到满足以上条件的算法难度有多大。所以，RSA 等可 以实现公开密钥加密的算法的提出，对当今互联网社会的安全有着重要的意义。
JAVA实现RSA加密
我们用Java实现下RSA加密
- 创建RSAUtils文件，编写RSA加密工具类
package com.lk.util;
import java.util.Base64;
import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
/**
* RSA加密工具类
*/
public class RSAUtils {
/**
* 密钥长度 于原文长度对应 以及越长速度越慢
*/
private final static int KEY_SIZE = 1024;
/**
* 用于封装随机产生的公钥与私钥
*/
private static Map<Integer, String> keyMap = new HashMap<Integer, String>();
/**
* 随机生成密钥对
*/
public static Map genKeyPair() throws NoSuchAlgorithmException {
// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
// 初始化密钥对生成器
keyPairGen.initialize(KEY_SIZE, new SecureRandom());
// 生成一个密钥对，保存在keyPair中
KeyPair keyPair = keyPairGen.generateKeyPair();
// 得到私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
// 得到公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
String publicKeyString = Base64.getEncoder().encodeToString(publicKey.getEncoded());
// 得到私钥字符串
String privateKeyString = Base64.getEncoder().encodeToString(privateKey.getEncoded());
// 将公钥和私钥保存到Map
//0表示公钥
keyMap.put(0, publicKeyString);
//1表示私钥
keyMap.put(1, privateKeyString);
return keyMap;
}
/**
* RSA公钥加密
*
* @param str 加密字符串
* @param publicKey 公钥
* @return 密文
* @throws Exception 加密过程中的异常信息
*/
public static String encrypt(String str, String publicKey) throws Exception {
//base64编码的公钥
byte[] decoded = Base64.getDecoder().decode(publicKey);
RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
//RSA加密
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, pubKey);
String outStr = Base64.getEncoder().encodeToString(cipher.doFinal(str.getBytes("UTF-8")));
return outStr;
}
/**
* RSA私钥解密
*
* @param str 加密字符串
* @param privateKey 私钥
* @return 明文
* @throws Exception 解密过程中的异常信息
*/
public static String decrypt(String str, String privateKey) throws Exception {
//64位解码加密后的字符串
byte[] inputByte = Base64.getDecoder().decode(str);
//base64编码的私钥
byte[] decoded = Base64.getDecoder().decode(privateKey);
RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
//RSA解密
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, priKey);
String outStr = new String(cipher.doFinal(inputByte));
return outStr;
}
}
- 在main函数中测试工具类
public static void main(String[] args) throws Exception {
// 随机生成的密钥和公钥
Map<Integer, String> keyMap = new HashMap<Integer, String>();
//生成公钥和私钥
keyMap = RSAUtils.genKeyPair();
System.out.println("公钥:" keyMap.get(0));
System.out.println("私钥:" keyMap.get(1));
// 要加密的数据
String message = "你好，我是通过RSA加密的数据";
// 使用公钥加密
String messageEn = RSAUtils.encrypt(message, keyMap.get(0));
System.out.println("密文:" messageEn);
// 使用私钥解密
String messageDe = RSAUtils.decrypt(messageEn, keyMap.get(1));
System.out.println("解密:" messageDe);
}
写在最后
- 文中使用的图片源自《我的第一本算法书》，如若侵权，请评论区留言，作者立即删除相关图片。
- 文中如有错误，欢迎在评论区指正
- 本文首发于掘金，未经许可禁止转载
