腳本之家服務器常用軟件

快捷導航

一文盤點五種最常用的Java加密算法

更新時間：2023年06月15日 15:56:44 作者：三分惡

大家平時的工作中，可能也在很多地方用到了加密、解密，比如：支付功能等，所以本文為大家盤點了Java中五個常用的加密算法，希望對大家有所幫助

前言

大家平時的工作中，可能也在很多地方用到了加密、解密，比如：

用戶的密碼不能明文存儲，要存儲加密后的密文

用戶的銀行卡號、身份證號之類的敏感數據，需要加密傳輸

還有一些重要接口，比如支付，客戶端要對請求生成一個簽名，服務端要對簽名進行驗證

……

那么上面提到的這些能力，我們都可以利用哪些加密算法來實現呢？咱們接著往下看。

常見加密算法

算法整體上可以分為不可逆加密，以及可逆加密，可逆加密又可以分為對稱加密和非對稱加密。

不可逆算法

不可逆加密的算法的加密是不可逆的，密文無法被還原成原文。

散列算法，就是一種不可逆算法。散列算法中，明文通過散列算法生成散列值，散列值是長度固定的數據，和明文長度無關。

散列算法的具體實現有很多種，常見的包括MD5、SHA1、SHA-224、SHA-256等等。

散列算法常用于數字簽名、消息認證、密碼存儲等場景。

散列算法是不需要密鑰的，當然也有一些不可逆算法，需要密鑰，例如HMAC算法。

MD5

MD5，全稱為“Message-Digest Algorithm 5”，翻譯過來叫“信息摘要算法”。它可以將任意長度的數據通過散列算法，生成一個固定長度的散列值。MD5算法的輸出長度為128位，通常用32個16進制數表示。

我們來看下MD5算法的Java代碼實現：

public class MD5 {
    private static final String MD5_ALGORITHM = "MD5";
    public static String encrypt(String data) throws Exception {
        // 獲取MD5算法實例
        MessageDigest messageDigest = MessageDigest.getInstance(MD5_ALGORITHM);
        // 計算散列值
        byte[] digest = messageDigest.digest(data.getBytes());
        Formatter formatter = new Formatter();
        // 補齊前導0，并格式化
        for (byte b : digest) {
            formatter.format("%02x", b);
        }
        return formatter.toString();
    }
    public static void main(String[] args) throws Exception {
        String data = "Hello World";
        String encryptedData = encrypt(data);
        System.out.println("加密后的數據：" + encryptedData);
    }
}

MD5有一些優(yōu)點，比如計算速度快、輸出長度固定、應用廣泛等等。

但是作為一個加密算法，它有一個天大的缺點，那就是不安全。

MD5算法已經被攻破，而且MD5算法的輸出長度有限，攻擊者可以通過暴力破解或彩虹表攻擊等方式，找到與原始數據相同的散列值，從而破解數據。

雖然可以通過加鹽，也就是對在原文里再加上一些不固定的字符串來緩解，但是完全可以用更安全的SHA系列算法替代。

SHA-256

SHA（Secure Hash Algorithm）系列算法是一組密碼散列函數，用于將任意長度的數據映射為固定長度的散列值。SHA系列算法由美國國家安全局（NSA）于1993年設計，目前共有SHA-1、SHA-2、SHA-3三種版本。

其中SHA-1系列存在缺陷，已經不再被推薦使用。

SHA-2算法包括SHA-224、SHA-256、SHA-384和SHA-512四種散列函數，分別將任意長度的數據映射為224位、256位、384位和512位的散列值。

我們來看一下最常用的SHA-256的Java代碼實現：

public class SHA256 {
    private static final String SHA_256_ALGORITHM = "SHA-256";
    public static String encrypt(String data) throws Exception {
        //獲取SHA-256算法實例
        MessageDigest messageDigest = MessageDigest.getInstance(SHA_256_ALGORITHM);
        //計算散列值
        byte[] digest = messageDigest.digest(data.getBytes());
        StringBuilder stringBuilder = new StringBuilder();
        //將byte數組轉換為15進制字符串
        for (byte b : digest) {
            stringBuilder.append(Integer.toHexString((b & 0xFF) | 0x100), 1, 3);
        }
        return stringBuilder.toString();
    }
    public static void main(String[] args) throws Exception {
        String data = "Hello World";
        String encryptedData = encrypt(data);
        System.out.println("加密后的數據：" + encryptedData);
    }
}

SHA-2算法之所以比MD5強，主要有兩個原因：

散列值長度更長：例如SHA-256算法的散列值長度為256位，而MD5算法的散列值長度為128位，這就提高了攻擊者暴力破解或者彩虹表攻擊的難度。
更強的碰撞抗性：SHA算法采用了更復雜的運算過程和更多的輪次，使得攻擊者更難以通過預計算或巧合找到碰撞。

當然，SHA-2也不是絕對安全的，散列算法都有被暴力破解或者彩虹表攻擊的風險，所以，在實際的應用中，加鹽還是必不可少的。

對稱加密算法

對稱加密算法，使用同一個密鑰進行加密和解密。

加密和解密過程使用的是相同的密鑰，因此密鑰的安全性至關重要。如果密鑰泄露，攻擊者可以輕易地破解加密數據。

常見的對稱加密算法包括DES、3DES、AES等。其中，AES算法是目前使用最廣泛的對稱加密算法之一，具有比較高的安全性和加密效率。

DES

DES（Data Encryption Standard）算法是一種對稱加密算法，由IBM公司于1975年研發(fā)，是最早的一種廣泛應用的對稱加密算法之一。

DES算法使用56位密鑰對數據進行加密，加密過程中使用了置換、替換、異或等運算，具有較高的安全性。

我們來看下DES算法的Java代碼實現：

public class DES {
    private static final String DES_ALGORITHM = "DES";
    /**
     * DES加密
     *
     * @param data 待加密的數據
     * @param key  密鑰，長度必須為8位
     * @return 加密后的數據，使用Base64編碼
     */
    public static String encrypt(String data, String key) throws Exception {
        // 根據密鑰生成密鑰規(guī)范
        KeySpec keySpec = new DESKeySpec(key.getBytes());
        // 根據密鑰規(guī)范生成密鑰工廠
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM);
        // 根據密鑰工廠和密鑰規(guī)范生成密鑰
        SecretKey secretKey = secretKeyFactory.generateSecret(keySpec);
        // 根據加密算法獲取加密器
        Cipher cipher = Cipher.getInstance(DES_ALGORITHM);
        // 初始化加密器，設置加密模式和密鑰
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        // 加密數據
        byte[] encryptedData = cipher.doFinal(data.getBytes());
        // 對加密后的數據進行Base64編碼
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    /**
     * DES解密
     *
     * @param encryptedData 加密后的數據，使用Base64編碼
     * @param key           密鑰，長度必須為8位
     * @return 解密后的數據
     */
    public static String decrypt(String encryptedData, String key) throws Exception {
        // 根據密鑰生成密鑰規(guī)范
        KeySpec keySpec = new DESKeySpec(key.getBytes());
        // 根據密鑰規(guī)范生成密鑰工廠
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(DES_ALGORITHM);
        // 根據密鑰工廠和密鑰規(guī)范生成密鑰
        SecretKey secretKey = secretKeyFactory.generateSecret(keySpec);
        // 對加密后的數據進行Base64解碼
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        // 根據加密算法獲取解密器
        Cipher cipher = Cipher.getInstance(DES_ALGORITHM);
        // 初始化解密器，設置解密模式和密鑰
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        // 解密數據
        byte[] decryptedData = cipher.doFinal(decodedData);
        // 將解密后的數據轉換為字符串
        return new String(decryptedData);
    }
    public static void main(String[] args) throws Exception {
        String data = "Hello World";
        String key = "12345678"; 
        String encryptedData = encrypt(data, key);
        System.out.println("加密后的數據：" + encryptedData);
        String decryptedData = decrypt(encryptedData, key);
        System.out.println("解密后的數據：" + decryptedData);
    }
}

DES的算法速度較快，但是在安全性上面并不是最優(yōu)選擇，因為DES算法的密鑰長度比較短，被暴力破解和差分攻擊的風險比較高，一般推薦用一些更安全的對稱加密算法，比如3DES、AES。

AES

AES（Advanced Encryption Standard）即高級加密標準，是一種對稱加密算法，被廣泛應用于數據加密和保護領域。AES算法使用的密鑰長度為128位、192位或256位，比DES算法的密鑰長度更長，安全性更高。

我們來看下AES算法的Java代碼實現：

public class AES {
    private static final String AES_ALGORITHM = "AES";
    // AES加密模式為CBC，填充方式為PKCS5Padding
    private static final String AES_TRANSFORMATION = "AES/CBC/PKCS5Padding";
    // AES密鑰為16位
    private static final String AES_KEY = "1234567890123456";
    // AES初始化向量為16位
    private static final String AES_IV = "abcdefghijklmnop";
    /**
     * AES加密
     *
     * @param data 待加密的數據
     * @return 加密后的數據，使用Base64編碼
     */
    public static String encrypt(String data) throws Exception {
        // 將AES密鑰轉換為SecretKeySpec對象
        SecretKeySpec secretKeySpec = new SecretKeySpec(AES_KEY.getBytes(), AES_ALGORITHM);
        // 將AES初始化向量轉換為IvParameterSpec對象
        IvParameterSpec ivParameterSpec = new IvParameterSpec(AES_IV.getBytes());
        // 根據加密算法獲取加密器
        Cipher cipher = Cipher.getInstance(AES_TRANSFORMATION);
        // 初始化加密器，設置加密模式、密鑰和初始化向量
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
        // 加密數據
        byte[] encryptedData = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        // 對加密后的數據使用Base64編碼
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    /**
     * AES解密
     *
     * @param encryptedData 加密后的數據，使用Base64編碼
     * @return 解密后的數據
     */
    public static String decrypt(String encryptedData) throws Exception {
        // 將AES密鑰轉換為SecretKeySpec對象
        SecretKeySpec secretKeySpec = new SecretKeySpec(AES_KEY.getBytes(), AES_ALGORITHM);
        // 將AES初始化向量轉換為IvParameterSpec對象
        IvParameterSpec ivParameterSpec = new IvParameterSpec(AES_IV.getBytes());
        // 根據加密算法獲取解密器
        Cipher cipher = Cipher.getInstance(AES_TRANSFORMATION);
        // 初始化解密器，設置解密模式、密鑰和初始化向量
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
        // 對加密后的數據使用Base64解碼
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        // 解密數據
        byte[] decryptedData = cipher.doFinal(decodedData);
        // 返回解密后的數據
        return new String(decryptedData, StandardCharsets.UTF_8);
    }
    public static void main(String[] args) throws Exception {
        String data = "Hello World";
        String encryptedData = encrypt(data);
        System.out.println("加密后的數據：" + encryptedData);
        String decryptedData = decrypt(encryptedData);
        System.out.println("解密后的數據：" + decryptedData);
    }
}

AES算法采用的密鑰長度更長，密鑰空間更大，安全性更高，能夠有效地抵抗暴力破解攻擊。

當然，因為密鑰長度較長，需要的存儲也更多。

對于對稱加密算法而言，最大的痛點就在于密鑰管理困難，相比而言，非對稱加密就沒有這個擔憂。

非對稱加密算法

非對稱加密算法需要兩個密鑰，這兩個密鑰互不相同，但是相互匹配，一個稱為公鑰，另一個稱為私鑰。

使用其中的一個加密，則使用另一個進行解密。例如使用公鑰加密，則需要使用私鑰解密。

RSA

RSA算法是是目前應用最廣泛的非對稱加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman三人在1978年發(fā)明，名字來源三人的姓氏首字母。

我們看下RSA算法的Java實現：

public class RSA {
    private static final String RSA_ALGORITHM = "RSA";
    /**
     * 生成RSA密鑰對
     *
     * @return RSA密鑰對
     */
    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        keyPairGenerator.initialize(2048); // 密鑰大小為2048位
        return keyPairGenerator.generateKeyPair();
    }
    /**
     * 使用公鑰加密數據
     *
     * @param data      待加密的數據
     * @param publicKey 公鑰
     * @return 加密后的數據
     */
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedData = cipher.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(encryptedData);
    }
    /**
     * 使用私鑰解密數據
     *
     * @param encryptedData 加密后的數據
     * @param privateKey    私鑰
     * @return 解密后的數據
     */
    public static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {
        byte[] decodedData = Base64.getDecoder().decode(encryptedData);
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedData = cipher.doFinal(decodedData);
        return new String(decryptedData, StandardCharsets.UTF_8);
    }
    public static void main(String[] args) throws Exception {
        KeyPair keyPair = generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        String data = "Hello World";
        String encryptedData = encrypt(data, publicKey);
        System.out.println("加密后的數據：" + encryptedData);
        String decryptedData = decrypt(encryptedData, privateKey);
        System.out.println("解密后的數據：" + decryptedData);
    }
}

RSA算法的優(yōu)點是安全性高，公鑰可以公開，私鑰必須保密，保證了數據的安全性；可用于數字簽名、密鑰協(xié)商等多種應用場景。

缺點是加密、解密速度較慢，密鑰長度越長，加密、解密時間越長；密鑰長度過短容易被暴力破解，密鑰長度過長則會增加計算量和存儲空間的開銷。