文章/答案/技术大牛

发布

社区首页 >专栏 >共享密钥加密与公开密钥加密

共享密钥加密与公开密钥加密

神奇的程序员

发布于 2022-04-10 01:09:03

2.9K00

代码可运行

文章被收录于专栏：神奇的程序员的专栏神奇的程序员的专栏

运行总次数：0

代码可运行

前言

加密数据的方法可以分为两种：加密和解密都使用相同密钥的“共享密钥加密”和分别使用不同密钥的“公开密钥加密”。

本文将以图文的形式讲解这两种加密的机制以及相关问题，挑选使用最为广泛两种加密算法，用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);
    }