五種常見的加密算法，建議掌握！

作者：猿java 2025-03-11 08:10:00

安全數據安全

本文我們分析了五種常見的加密算法，不同的加密方式各有優缺點，適用于不同的應用場景。

在實際工作中，對于數據保護、身份驗證、通信安全這些有數據安全的場景，我們通常會對數據進行加密。那么，常用的加密技術有哪些？它們有什么優缺點？我們該如何選擇？這篇文章我們來聊一聊 5種常見的加密算法。

1. 對稱加密

對稱加密（Symmetric Encryption）是工作中比較常見的一種基于密鑰的加密技術，它的特點就是使用相同的密鑰進行加密和解密，算法簡單高效。

對稱加密常見的算法：

AES（高級加密標準）：目前最廣泛使用的對稱加密算法，具有高安全性和高效性。
DES（數據加密標準）：較早的對稱加密算法，因安全性較低現已較少使用。
3DES（Triple DES）：對DES算法的改進，通過三次加密提高安全性。
Blowfish、Twofish：適用于不同應用場景的靈活對稱加密算法。

優點：

高安全性，被廣泛認可和使用。
支持多種密鑰長度（128、192、256位）。
加解密速度快，適合大數據量加密。

缺點：

密鑰分發問題，需確保密鑰在發送方和接收方之間安全傳輸。
不適合加密少量數據或需要頻繁修改密鑰的場景。

使用場景：

數據存儲加密：如磁盤加密（BitLocker、FileVault）、數據庫加密，確保存儲在磁盤或數據庫中的數據不被未授權訪問。
通信加密：用于VPN、TLS/SSL協議中的數據傳輸加密，保障網絡通信的機密性和完整性。
應用程序加密：保護應用程序內部的數據，如配置文件、緩存數據等。

Java示例：

以下的示例展示了如何使用 Java實現AES 加密與解密。

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

publicclass 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);
        returnnew 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. 非對稱加密

非對稱加密（Asymmetric Encryption）是對稱加密的一個升級版本，不再使用相同的秘密，而是使用了一對密鑰——公鑰和私鑰。公鑰用于加密，私鑰用于解密，密鑰之間數學相關但無法從公鑰輕易推導出私鑰。

非對稱加密的常見算法：

RSA：廣泛應用的非對稱加密算法，適用于數據加密和數字簽名。
ECC（橢圓曲線加密）：在相同安全水平下具有更短密鑰長度，效率更高，適用于移動設備和嵌入式系統。
DSA（數字簽名算法）：主要用于數字簽名，確保數據的完整性和來源。

使用場景：

安全通信：用于SSL/TLS協議中的密鑰交換，確保雙方通信的安全性。
數字簽名：驗證數據的來源和完整性，如電子郵件簽名、代碼簽名、文件簽名等。
身份驗證：在身份驗證系統中，使用公鑰基礎設施（PKI）進行用戶身份驗證和授權。

Java示例：

以下的示例展示了如何使用 Java實現RSA 加密與解密。

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

publicclass 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));
        returnnew 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();
        }
    }
}

注意：在實際應用中，建議使用更為安全的填充模式（如OAEP），而不是簡單的PKCS#1填充。

3. 哈希函數

哈希函數（Hash Functions）是將任意長度的輸入數據映射為固定長度的哈希值，且具有單向性（不可逆）和抗碰撞性（難以找到不同輸入具有相同哈希值）。比如工作中，我們會生成一個全局ID，然后通過哈希算法進行壓縮。

哈希算法常見的算法：

SHA-256、SHA-3：廣泛用于數據完整性驗證和區塊鏈技術。
MD5、SHA-1：由于安全性問題逐漸被淘汰，但仍在某些遺留系統中使用。

使用場景：

數據完整性驗證：通過比較哈希值確保數據在傳輸或存儲過程中未被篡改。
密碼存儲：將用戶密碼進行哈希存儲，增加密碼泄露后的安全性（通常結合加鹽技術）。
數字簽名：在簽名過程中，先對數據進行哈希，再對哈希值進行加密，提高效率和安全性。

Java 示例代碼

下面給出了一個基于 SHA-256 哈希函數的示例：

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

publicclass 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. 量子加密

量子加密（Quantum Encryption）主要指基于量子力學原理的加密技術，其中最著名的是量子密鑰分發（Quantum Key Distribution, QKD）。QKD利用量子態的不可克隆性和測量的擾動性，確保密鑰在傳輸過程中絕對安全，即使面臨具備量子計算能力的攻擊者。

在普通的開發中一般很少用到這個算法，但是信息安全領域比較常見。

量子加密常見技術：

量子密鑰分發（QKD）：通過量子態傳輸密鑰，確保密鑰交換過程的安全性。

使用場景：

高安全需求的通信：政府、軍事和金融機構等需要最高級別安全保護的通信領域。
未來網絡安全：為應對量子計算機對現有加密算法的威脅，量子加密技術正逐步研究和應用。

Java示例：

下面的示例，我們使用 Java模擬BB84協議。主要步驟說明如下：

Alice生成比特和基：隨機生成一串比特（0或1）和對應的基（"+"或"×"）。
Bob測量比特：對每個接收到的比特，Bob隨機選擇一個基進行測量。如果Alice和Bob的基相同，Bob測量結果應與Alice的比特相同；否則，測量結果是隨機的。
基匹配與密鑰生成： Alice和Bob共享基信息，并保留基相同的比特作為密鑰。
安全性檢測：隨機抽取部分密鑰進行比對，判斷是否存在竊聽。

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

publicclass 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%%\n", 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. 混合加密

混合加密（Hybrid Encryption），顧名思義，就是將多種加密算法混合使用。比如將對稱加密和非對稱加密混合，先使用非對稱加密交換對稱加密的會話密鑰，再使用對稱加密進行數據傳輸。

使用場景：

SSL/TLS協議：在建立安全連接時，利用非對稱加密進行密鑰交換，隨后使用對稱加密進行數據傳輸，兼顧安全性和效率。
加密通信工具：如PGP（Pretty Good Privacy），用于加密電子郵件和文件傳輸。

總結

本文，我們分析了五種常見的加密算法：

對稱加密
非對稱加密
Hash算法
量子加密
混合加密

不同的加密方式各有優缺點，適用于不同的應用場景。在實際工作中，我們在使用這些加密算法時一定要特別注意其優缺點，同時也需要關注實現的復雜度。

責任編輯：趙寧寧來源：猿java

加密數據安全數據保護