5种常见的加密算法，从零基础到精通，收藏这篇就够了！

数据安全？这四个字可不是说说而已。面对黑客们层出不穷的攻击手段，加密技术就是咱们网络安全工程师的最后一道防线！ 还在啃那些枯燥的教科书？醒醒吧！今天，咱就来聊聊五种加密算法，保证让你看完之后，知其然，更知其所以然！

1. 对称加密：速度是王道，但密钥分发是个坑

对称加密，简单粗暴，说白了就是加密解密用同一个钥匙。 这玩意儿最大的优点就是快！ 比特币交易速度快的原因之一，就是大量使用了对称加密算法。

常见的对称加密算法，你必须知道的：

• AES（高级加密标准）：这年头，谁还不用AES？ 安全性高，效率又好，简直是加密界的当红炸子鸡。
• DES（数据加密标准）：老古董了，安全性堪忧，现在基本没人用。
• 3DES（Triple DES）：想当年，为了弥补DES的不足，搞出了这么个“三重加密”，但现在看来，还是不够看。
• Blowfish、Twofish：这两兄弟比较灵活，适合一些特定的应用场景。

优点：

• 速度快！重要的事情说三遍。
• 密钥长度可选，灵活性还行。

缺点：

• 密钥分发是个大问题！ 怎么把钥匙安全地交给对方？ 这可是一个头疼的问题。
• 不太适合小数据加密，频繁换密钥也麻烦。

应用场景：

• 数据存储加密：硬盘加密、数据库加密，防止内部人员或者黑客直接偷数据。
• 通信加密：VPN、SSL/TLS，保证网络传输过程中的数据安全。
• 应用内部数据加密：配置文件、缓存数据，防止敏感信息泄露。

Java代码示例：

下面这段代码，用Java实现了AES加密解密。 别光看代码，要理解背后的原理！

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESDemo {
    // 生成AES密钥
    public static SecretKey generateAESKey(int n) throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(n);  // 128, 192, or 256
        return keyGen.generateKey();
    }

    // 加密
    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encrypted = cipher.doFinal(data.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encrypted);
    }

    // 解密
    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decodedBytes = Base64.getDecoder().decode(encryptedData);
        byte[] decrypted = cipher.doFinal(decodedBytes);
        return new String(decrypted, "UTF-8");
    }

    public static void main(String[] args) throws Exception {
        String originalText = "Hello, AES Encryption!";
        SecretKey secretKey = generateAESKey(128);

        String encryptedText = encrypt(originalText, secretKey);
        System.out.println("Encrypted: " + encryptedText);

        String decryptedText = decrypt(encryptedText, secretKey);
        System.out.println("Decrypted: " + decryptedText);
    }
}

2. 非对称加密：公钥私钥，安全但慢如蜗牛

非对称加密，听着高大上，其实就是用一对钥匙：公钥和私钥。 公钥随便给人，私钥自己藏好。 公钥加密，私钥解密，反过来也行。

常见的非对称加密算法：

• RSA：应用最广泛的非对称加密算法，加密、签名都能干。
• ECC（椭圆曲线加密）：密钥更短，效率更高，移动设备上用的比较多。
• DSA（数字签名算法）：专门用来做数字签名，保证数据没被篡改。

优点：

• 解决了密钥分发问题，安全性更高。

缺点：

• 速度慢！ 比对称加密慢多了，不适合加密大数据。

应用场景：

• 安全通信：SSL/TLS握手阶段，用非对称加密交换对称密钥。
• 数字签名：验证软件、邮件的真伪。
• 身份验证：PKI体系，用户身份认证。

Java 代码示例：

RSA加密解密示例，注意填充模式的选择！

import java.security.*;
import javax.crypto.Cipher;
import java.util.Base64;

public class RSADemo {
    // 生成RSA密钥对
    public static KeyPair generateRSAKeyPair(int keySize) throws NoSuchAlgorithmException {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
        keyGen.initialize(keySize, new SecureRandom());
        return keyGen.generateKeyPair();
    }

    // 使用RSA公钥加密
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");  // 使用OAEP填充
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes("UTF-8"));
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    // 使用RSA私钥解密
    public static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");  // 使用OAEP填充
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes, "UTF-8");
    }

    public static void main(String[] args) {
        try {
            String originalText = "Hello, This is RSA Encryption!";
            // 生成RSA密钥对
            KeyPair keyPair = generateRSAKeyPair(2048);

            // 加密
            String encryptedText = encrypt(originalText, keyPair.getPublic());
            System.out.println("Encrypted (RSA): " + encryptedText);

            // 解密
            String decryptedText = decrypt(encryptedText, keyPair.getPrivate());
            System.out.println("Decrypted (RSA): " + decryptedText);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 哈希函数：单向加密，数据指纹

哈希函数，也叫散列函数，它能把任意长度的数据变成固定长度的哈希值。 关键是，这个过程是不可逆的！ 你没法从哈希值反推出原始数据。 这玩意儿就像是给数据生成了一个“指纹”。

常见的哈希算法：

• SHA-256、SHA-3：安全性高，区块链技术的核心。
• MD5、SHA-1：老掉牙了，安全性不行，别用了！

应用场景：

• 数据完整性验证：下载文件后，算一下哈希值，和官方提供的对比一下，就知道文件有没有被篡改。
• 密码存储：用户密码经过哈希后存储，即使数据库泄露，黑客也拿不到明文密码（当然，还得加盐！）。
• 数字签名：先对数据哈希，再对哈希值签名，提高效率。

Java 示例代码：

SHA-256 哈希示例：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class SHADemo {
    public static String hashSHA256(String data) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashBytes = digest.digest(data.getBytes());

        // 转换为十六进制字符串
        StringBuilder sb = new StringBuilder();
        for (byte b : hashBytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        String originalText = "Hello, SHA-256 Hash!";
        String hash = hashSHA256(originalText);
        System.out.println("SHA-256 Hash: " + hash);
    }
}

4. 量子加密：未来战士，绝对安全？

量子加密，听起来就科幻感十足。 它基于量子力学原理，利用量子态的特性来保证密钥的安全。 其中最牛逼的就是量子密钥分发（QKD），理论上可以实现绝对安全的密钥传输。

量子加密的核心技术：

• 量子密钥分发（QKD）：利用量子纠缠、量子不可克隆原理，保证密钥传输过程中不被窃听。

应用场景：

• 高安全通信：政府、军队、金融机构，对安全性要求极高的领域。
• 未来网络安全：对抗量子计算机的威胁。

Java 示例代码：

用Java模拟BB84协议，感受一下量子加密的魅力：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

public class BB84Demo {
    public static void main(String[] args) {
        int keyLength = 100;  // 初始密钥长度
        double eavesdropProb = 0.05; // 窃听概率，即Eve拦截的比特比例

        // Alice生成随机比特和基
        List<Integer> aliceBits = generateRandomBits(keyLength);
        List<Character> aliceBases = generateRandomBases(keyLength);

        // Eve可能窃听部分比特
        List<Integer> eavesdroppedBits = new ArrayList<>();
        List<Character> eavesdroppedBases = new ArrayList<>();
        Random rand = new Random();
        for (int i = 0; i < keyLength; i++) {
            if (rand.nextDouble() < eavesdropProb) {
                // Eve窃听
                char eBase = rand.nextBoolean() ? '+' : '×';
                eavesdroppedBases.add(eBase);
                // 如果Eve的基与Alice相同，Eve获取正确的比特；否则，Eve随机比特
                if (eBase == aliceBases.get(i)) {
                    eavesdroppedBits.add(aliceBits.get(i));
                } else {
                    eavesdroppedBits.add(rand.nextBoolean() ? 1 : 0);
                }
            } else {
                eavesdroppedBits.add(null); // 没有窃听
            }
        }

        // Bob接收量子比特，进行测量
        List<Integer> bobBits = new ArrayList<>();
        List<Character> bobBases = generateRandomBases(keyLength);
        for (int i = 0; i < keyLength; i++) {
            char bBase = bobBases.get(i);
            if (eavesdroppedBits.get(i) != null) {
                // 如果Eve窃听了这个比特，Bob的测量可能受到影响
                if (bBase == aliceBases.get(i)) {
                    bobBits.add(eavesdroppedBits.get(i));
                } else {
                    bobBits.add(rand.nextBoolean() ? 1 : 0);
                }
            } else {
                // 没有被窃听
                if (bBase == aliceBases.get(i)) {
                    bobBits.add(aliceBits.get(i));
                } else {
                    bobBits.add(rand.nextBoolean() ? 1 : 0);
                }
            }
        }

        // Alice和Bob公开基，保留基相同的比特
        List<Integer> aliceKey = new ArrayList<>();
        List<Integer> bobKey = new ArrayList<>();
        for (int i = 0; i < keyLength; i++) {
            if (aliceBases.get(i).equals(bobBases.get(i))) {
                aliceKey.add(aliceBits.get(i));
                bobKey.add(bobBits.get(i));
            }
        }

        System.out.println("Alice的初始比特序列: " + aliceBits);
        System.out.println("Alice的基序列: " + aliceBases);
        System.out.println("Bob的基序列: " + bobBases);
        System.out.println("Eve窃听的比特序列: " + eavesdroppedBits);
        System.out.println("Alice和Bob共享的密钥长度: " + aliceKey.size());

        // 安全性检测：随机抽取部分密钥进行比对
        int testSize = Math.min(10, aliceKey.size()); // 抽取10个比特进行测试
        List<Integer> aliceTest = new ArrayList<>();
        List<Integer> bobTest = new ArrayList<>();
        Random testRand = new Random();
        List<Integer> indices = new ArrayList<>();
        while (indices.size() < testSize) {
            int index = testRand.nextInt(aliceKey.size());
            if (!indices.contains(index)) {
                indices.add(index);
                aliceTest.add(aliceKey.get(index));
                bobTest.add(bobKey.get(index));
            }
        }

        System.out.println("Alice的测试比特: " + aliceTest);
        System.out.println("Bob的测试比特: " + bobTest);

        // 计算错误率
        int errorCount = 0;
        for (int i = 0; i < testSize; i++) {
            if (!aliceTest.get(i).equals(bobTest.get(i))) {
                errorCount++;
            }
        }
        double errorRate = (double) errorCount / testSize;
        System.out.printf("测试错误率: %.2f%%
", errorRate * 100);

        if (errorRate > 0.1) { // 假设错误率大于10%认为存在窃听
            System.out.println("检测到潜在的窃听行为，放弃当前密钥并重新生成。");
        } else {
            // 移除测试比特后，剩余的密钥作为最终共享密钥
            List<Integer> finalKey = aliceKey.stream()
                    .collect(Collectors.toList());
            for (int index : indices) {
                finalKey.set(index, null);
            }
            finalKey = finalKey.stream().filter(bit -> bit != null).collect(Collectors.toList());
            System.out.println("最终共享的密钥: " + finalKey);
        }
    }

    // 生成随机比特序列
    public static List<Integer> generateRandomBits(int length) {
        List<Integer> bits = new ArrayList<>(length);
        Random rand = new Random();
        for (int i = 0; i < length; i++) {
            bits.add(rand.nextBoolean() ? 1 : 0);
        }
        return bits;
    }

    // 生成随机基序列
    public static List<Character> generateRandomBases(int length) {
        List<Character> bases = new ArrayList<>(length);
        Random rand = new Random();
        for (int i = 0; i < length; i++) {
            bases.add(rand.nextBoolean() ? '+' : '×');
        }
        return bases;
    }
}

5. 混合加密：鱼和熊掌兼得

混合加密，就是把对称加密和非对称加密结合起来用。 先用非对称加密交换对称密钥，然后用对称加密传输数据。 这样既保证了安全，又兼顾了效率。

应用场景：

• SSL/TLS协议：HTTPS的核心。
• 加密通信工具：PGP，加密邮件、文件。

最后，总结一下！

今天，咱们聊了五种加密算法：

1. 对称加密：速度快，但密钥分发是个问题。
2. 非对称加密：安全，但速度慢。
3. 哈希函数：单向加密，数据指纹。
4. 量子加密：未来趋势，理论上绝对安全。
5. 混合加密：兼顾安全和效率。

选择哪种加密算法，要根据具体的应用场景来决定。 没有万能的加密算法，只有最合适的！ 加油，各位未来的网络安全攻城狮！
```

黑客/网络安全学习包

资料目录

1. 成长路线图&学习规划

2. 配套视频教程

3. SRC&黑客文籍

4. 护网行动资料

5. 黑客必读书单

6. 面试题合集

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

*************************************CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享*************************************

1.成长路线图&学习规划

要学习一门新的技术，作为新手一定要先学习成长路线图，方向不对，努力白费。

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图&学习规划。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

*************************************CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享*************************************

2.视频教程

很多朋友都不喜欢晦涩的文字，我也为大家准备了视频教程，其中一共有21个章节，每个章节都是当前板块的精华浓缩。

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

*************************************CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享*************************************

3.SRC&黑客文籍

大家最喜欢也是最关心的SRC技术文籍&黑客技术也有收录

SRC技术文籍：

黑客资料由于是敏感资源，这里不能直接展示哦！

4.护网行动资料

其中关于HW护网行动，也准备了对应的资料，这些内容可相当于比赛的金手指！

5.黑客必读书单

**

**

6.面试题合集

当你自学到这里，你就要开始思考找工作的事情了，而工作绕不开的就是真题和面试题。

更多内容为防止和谐，可以扫描获取~

因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取

*************************************CSDN大礼包：《黑客&网络安全入门&进阶学习资源包》免费分享*********************************