[java]淺談常用的七種加密算法

前言

數字簽名、資訊加密是前後端開發都經常需要使用到的技術，應用場景包括了使用者登入、交易、資訊通訊、oauth 等等，不同的應用場景也會需要使用到不同的簽名加密算法，或者需要搭配不一樣的簽名加密算法來達到業務目标。這裡簡單的給大家介紹幾種常見的簽名加密算法和一些典型場景下的應用。

正文

1. 數字簽名

數字簽名，簡單來說就是通過提供可鑒别的數字資訊驗證自身身份的一種方式。一套數字簽名通常定義兩種互補的運算，一個用于簽名，另一個用于驗證。分别由發送者持有能夠代表自己身份的私鑰 (私鑰不可洩露),由接受者持有與私鑰對應的公鑰，能夠在接受到來自發送者資訊時用于驗證其身份。

注意：圖中加密過程有别于公鑰加密，更多介紹戳這裡。簽名最根本的用途是要能夠唯一證明發送方的身份，防止中間人攻擊、CSRF 跨域身份僞造。基于這一點在諸如裝置認證、使用者認證、第三方認證等認證體系中都會使用到簽名算法 (彼此的實作方式可能會有差異)。

2. 加密和解密

2.1. 加密

資料加密的基本過程，就是對原來為明文的檔案或資料按某種算法進行處理，使其成為不可讀的一段代碼，通常稱為 “密文”。通過這樣的途徑，來達到保護資料不被非法人竊取、閱讀的目的。

2.2. 解密

加密的逆過程為解密，即将該編碼資訊轉化為其原來資料的過程。

3. 對稱加密和非對稱加密

加密算法分對稱加密和非對稱加密，其中對稱加密算法的加密與解密密鑰相同，非對稱加密算法的加密密鑰與解密密鑰不同，此外，還有一類不需要密鑰的雜湊演算法。

常見的對稱加密算法主要有 DES、3DES、AES 等，常見的非對稱算法主要有 RSA、DSA 等，雜湊演算法主要有 SHA-1、MD5 等。

3.1. 對稱加密

對稱加密算法是應用較早的加密算法，又稱為共享密鑰加密算法。在對稱加密算法中，使用的密鑰隻有一個，發送和接收雙方都使用這個密鑰對資料進行加密和解密。這就要求加密和解密方事先都必須知道加密的密鑰。

資料加密過程：在對稱加密算法中，資料發送方将明文 (原始資料) 和加密密鑰一起經過特殊加密處理，生成複雜的加密密文進行發送。

資料解密過程：資料接收方收到密文後，若想讀取原資料，則需要使用加密使用的密鑰及相同算法的逆算法對加密的密文進行解密，才能使其恢複成可讀明文。

3.2. 非對稱加密

非對稱加密算法，又稱為公開密鑰加密算法。它需要兩個密鑰，一個稱為公開密鑰 (public key)，即公鑰，另一個稱為私有密鑰 (private key)，即私鑰。

因為加密和解密使用的是兩個不同的密鑰，是以這種算法稱為非對稱加密算法。

如果使用公鑰對資料進行加密，隻有用對應的私鑰才能進行解密。

如果使用私鑰對資料進行加密，隻有用對應的公鑰才能進行解密。

例子：甲方生成一對密鑰并将其中的一把作為公鑰向其它人公開，得到該公鑰的乙方使用該密鑰對機密資訊進行加密後再發送給甲方，甲方再使用自己儲存的另一把專用密鑰 (私鑰)，對加密後的資訊進行解密。

4. 常見的簽名加密算法

4.1. MD5算法

MD5 用的是哈希函數，它的典型應用是對一段資訊産生資訊摘要，以防止被篡改。嚴格來說，MD5 不是一種加密算法而是摘要算法。無論是多長的輸入，MD5 都會輸出長度為 128bits 的一個串 (通常用 16 進制表示為 32 個字元)。

public static final byte[] computeMD5(byte[] content) {

try {

MessageDigest md5 = MessageDigest.getInstance("MD5");

return md5.digest(content);

} catch (NoSuchAlgorithmException e) {

throw new RuntimeException(e);

}

4.2. SHA1算法

SHA1 是和 MD5 一樣流行的消息摘要算法，然而 SHA1 比 MD5 的安全性更強。對于長度小于 2 ^ 64 位的消息，SHA1 會産生一個 160 位的消息摘要。基于 MD5、SHA1 的資訊摘要特性以及不可逆 (一般而言)，可以被應用在檢查檔案完整性以及數字簽名等場景。

public static byte[] computeSHA1(byte[] content) {

try {

MessageDigest sha1 = MessageDigest.getInstance("SHA1");

return sha1.digest(content);

} catch (NoSuchAlgorithmException e) {

throw new RuntimeException(e);

}

4.3. HMAC算法

HMAC 是密鑰相關的哈希運算消息認證碼（Hash-based Message Authentication Code），HMAC 運算利用雜湊演算法 (MD5、SHA1 等)，以一個密鑰和一個消息為輸入，生成一個消息摘要作為輸出。

HMAC 發送方和接收方都有的 key 進行計算，而沒有這把 key 的第三方，則是無法計算出正确的散列值的，這樣就可以防止資料被篡改。

package net.pocrd.util;

import net.pocrd.annotation.NotThreadSafe;

import net.pocrd.define.ConstField;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.crypto.Mac;

import javax.crypto.SecretKey;

import javax.crypto.spec.SecretKeySpec;

import java.util.Arrays;

@NotThreadSafe

public class HMacHelper {

private static final Logger logger = LoggerFactory.getLogger(HMacHelper.class);

private Mac mac;

private static final String KEY_MAC = "HmacMD5";

public HMacHelper(String key) {

try {

SecretKey secretKey = new SecretKeySpec(key.getBytes(ConstField.UTF8), KEY_MAC);

mac = Mac.getInstance(secretKey.getAlgorithm());

mac.init(secretKey);

} catch (Exception e) {

logger.error("create hmac helper failed.", e);

}

public byte[] sign(byte[] content) {

return mac.doFinal(content);

}

public boolean verify(byte[] signature, byte[] content) {

try {

byte[] result = mac.doFinal(content);

return Arrays.equals(signature, result);

} catch (Exception e) {

logger.error("verify sig failed.", e);

}

return false;

}

測試結論：HMAC 算法執行個體在多線程環境下是不安全的。但是需要在多線程通路時，進行同步的輔助類，使用 ThreadLocal 為每個線程緩存一個執行個體可以避免進行鎖操作。

4.4. AES/DES/3DES算法

AES、DES、3DES 都是對稱的塊加密算法，加解密的過程是可逆的。常用的有 AES128、AES192、AES256 (預設安裝的 JDK 尚不支援 AES256，需要安裝對應的 jce 更新檔進行更新 jce1.7，jce1.8)。

4.4.1. DES算法

DES 加密算法是一種分組密碼，以 64 位為分組對資料加密，它的密鑰長度是 56 位，加密解密用同一算法。

DES 加密算法是對密鑰進行保密，而公開算法，包括加密和解密算法。這樣，隻有掌握了和發送方相同密鑰的人才能解讀由 DES加密算法加密的密文資料。是以，破譯 DES 加密算法實際上就是搜尋密鑰的編碼。對于 56 位長度的密鑰來說，如果用窮舉法來進行搜尋的話，其運算次數為 2 ^ 56 次。

4.4.2. 3DES算法

是基于 DES 的對稱算法，對一塊資料用三個不同的密鑰進行三次加密，強度更高。

4.4.3. AES算法

AES 加密算法是密碼學中的進階加密标準，該加密算法采用對稱分組密碼體制，密鑰長度的最少支援為 128 位、 192 位、256 位，分組長度 128 位，算法應易于各種硬體和軟體實作。這種加密算法是美國聯邦政府采用的區塊加密标準。

AES 本身就是為了取代 DES 的，AES 具有更好的安全性、效率和靈活性。

import net.pocrd.annotation.NotThreadSafe;

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import java.security.SecureRandom;

@NotThreadSafe

public class AesHelper {

private SecretKeySpec keySpec;

private IvParameterSpec iv;

public AesHelper(byte[] aesKey, byte[] iv) {

if (aesKey == null || aesKey.length < 16 || (iv != null && iv.length < 16)) {

throw new RuntimeException("錯誤的初始密鑰");

}

if (iv == null) {

iv = Md5Util.compute(aesKey);

}

keySpec = new SecretKeySpec(aesKey, "AES");

this.iv = new IvParameterSpec(iv);

}

public AesHelper(byte[] aesKey) {

if (aesKey == null || aesKey.length < 16) {

throw new RuntimeException("錯誤的初始密鑰");

}

keySpec = new SecretKeySpec(aesKey, "AES");

this.iv = new IvParameterSpec(Md5Util.compute(aesKey));

}

public byte[] encrypt(byte[] data) {

byte[] result = null;

Cipher cipher = null;

try {

cipher = Cipher.getInstance("AES/CFB/NoPadding");

cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);

result = cipher.doFinal(data);

} catch (Exception e) {

throw new RuntimeException(e);

}

return result;

}

public byte[] decrypt(byte[] secret) {

byte[] result = null;

Cipher cipher = null;

try {

cipher = Cipher.getInstance("AES/CFB/NoPadding");

cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);

result = cipher.doFinal(secret);

} catch (Exception e) {

throw new RuntimeException(e);

}

return result;

}

public static byte[] randomKey(int size) {

byte[] result = null;

try {

KeyGenerator gen = KeyGenerator.getInstance("AES");

gen.init(size, new SecureRandom());

result = gen.generateKey().getEncoded();

} catch (Exception e) {

throw new RuntimeException(e);

}

return result;

}

4.5. RSA算法

RSA 加密算法是目前最有影響力的公鑰加密算法，并且被普遍認為是目前最優秀的公鑰方案之一。RSA 是第一個能同時用于加密和數字簽名的算法，它能夠抵抗到目前為止已知的所有密碼攻擊，已被 ISO 推薦為公鑰資料加密标準。

RSA 加密算法基于一個十分簡單的數論事實：将兩個大素數相乘十分容易，但想要對其乘積進行因式分解卻極其困難，是以可以将乘積公開作為加密密鑰。

import net.pocrd.annotation.NotThreadSafe;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;

import java.security.KeyFactory;

import java.security.Security;

import java.security.Signature;

import java.security.interfaces.RSAPrivateCrtKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe

public class RsaHelper {

private static final Logger logger = LoggerFactory.getLogger(RsaHelper.class);

private RSAPublicKey publicKey;

private RSAPrivateCrtKey privateKey;

static {

Security.addProvider(new BouncyCastleProvider()); //使用bouncycastle作為加密算法實作

}

public RsaHelper(String publicKey, String privateKey) {

this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));

}

public RsaHelper(byte[] publicKey, byte[] privateKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

if (privateKey != null && privateKey.length > 0) {

this.privateKey = (RSAPrivateCrtKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));

}

} catch (Exception e) {

throw new RuntimeException(e);

}

public RsaHelper(String publicKey) {

this(Base64Util.decode(publicKey));

}

public RsaHelper(byte[] publicKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

} catch (Exception e) {

throw new RuntimeException(e);

}

public byte[] encrypt(byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

if (content == null) {

return null;

}

try {

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

int size = publicKey.getModulus().bitLength() / 8 - 11;

ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size * (size + 11));

int left = 0;

for (int i = 0; i < content.length; ) {

left = content.length - i;

if (left > size) {

cipher.update(content, i, size);

i += size;

} else {

cipher.update(content, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

throw new RuntimeException(e);

}

public byte[] decrypt(byte[] secret) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

if (secret == null) {

return null;

}

try {

Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

cipher.init(Cipher.DECRYPT_MODE, privateKey);

int size = privateKey.getModulus().bitLength() / 8;

ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size - 12) / (size - 11) * size);

int left = 0;

for (int i = 0; i < secret.length; ) {

left = secret.length - i;

if (left > size) {

cipher.update(secret, i, size);

i += size;

} else {

cipher.update(secret, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

logger.error("rsa decrypt failed.", e);

}

return null;

}

public byte[] sign(byte[] content) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

if (content == null) {

return null;

}

try {

Signature signature = Signature.getInstance("SHA1WithRSA");

signature.initSign(privateKey);

signature.update(content);

return signature.sign();

} catch (Exception e) {

throw new RuntimeException(e);

}

public boolean verify(byte[] sign, byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

if (sign == null || content == null) {

return false;

}

try {

Signature signature = Signature.getInstance("SHA1WithRSA");

signature.initVerify(publicKey);

signature.update(content);

return signature.verify(sign);

} catch (Exception e) {

logger.error("rsa verify failed.", e);

}

return false;

}

4.6. ECC算法

ECC 也是一種非對稱加密算法，主要優勢是在某些情況下，它比其他的方法使用更小的密鑰，比如 RSA 加密算法，提供相當的或更高等級的安全級别。不過一個缺點是加密和解密操作的實作比其他機制時間長 (相比 RSA 算法，該算法對 CPU 消耗嚴重)。

import net.pocrd.annotation.NotThreadSafe;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;

import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;

import java.io.ByteArrayOutputStream;

import java.security.KeyFactory;

import java.security.Security;

import java.security.Signature;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe

public class EccHelper {

private static final Logger logger = LoggerFactory.getLogger(EccHelper.class);

private static final int SIZE = 4096;

private BCECPublicKey publicKey;

private BCECPrivateKey privateKey;

static {

Security.addProvider(new BouncyCastleProvider());

}

public EccHelper(String publicKey, String privateKey) {

this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));

}

public EccHelper(byte[] publicKey, byte[] privateKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

if (privateKey != null && privateKey.length > 0) {

this.privateKey = (BCECPrivateKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));

}

} catch (ClassCastException e) {

throw new RuntimeException("", e);

} catch (Exception e) {

throw new RuntimeException(e);

}

public EccHelper(String publicKey) {

this(Base64Util.decode(publicKey));

}

public EccHelper(byte[] publicKey) {

try {

KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");

if (publicKey != null && publicKey.length > 0) {

this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));

}

} catch (Exception e) {

throw new RuntimeException(e);

}

public byte[] encrypt(byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

try {

Cipher cipher = Cipher.getInstance("ECIES", "BC");

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

int size = SIZE;

ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size * (size + 45));

int left = 0;

for (int i = 0; i < content.length; ) {

left = content.length - i;

if (left > size) {

cipher.update(content, i, size);

i += size;

} else {

cipher.update(content, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

throw new RuntimeException(e);

}

public byte[] decrypt(byte[] secret) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

try {

Cipher cipher = Cipher.getInstance("ECIES", "BC");

cipher.init(Cipher.DECRYPT_MODE, privateKey);

int size = SIZE + 45;

ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size + 44) / (size + 45) * size);

int left = 0;

for (int i = 0; i < secret.length; ) {

left = secret.length - i;

if (left > size) {

cipher.update(secret, i, size);

i += size;

} else {

cipher.update(secret, i, left);

i += left;

}

baos.write(cipher.doFinal());

}

return baos.toByteArray();

} catch (Exception e) {

logger.error("ecc decrypt failed.", e);

}

return null;

}

public byte[] sign(byte[] content) {

if (privateKey == null) {

throw new RuntimeException("private key is null.");

}

try {

Signature signature = Signature.getInstance("SHA1withECDSA", "BC");

signature.initSign(privateKey);

signature.update(content);

return signature.sign();

} catch (Exception e) {

throw new RuntimeException(e);

}

public boolean verify(byte[] sign, byte[] content) {

if (publicKey == null) {

throw new RuntimeException("public key is null.");

}

try {

Signature signature = Signature.getInstance("SHA1withECDSA", "BC");

signature.initVerify(publicKey);

signature.update(content);

return signature.verify(sign);

} catch (Exception e) {

logger.error("ecc verify failed.", e);

}

return false;

}

5. 各種加密算法對比

5.1. 雜湊演算法比較

名稱安全性速度

SHA-1 高慢

MD5 中快

5.2. 對稱加密算法比較

名稱密鑰名稱運作速度安全性資源消耗

DES 56位較快低中

3DES 112位或168位慢中高

AES 128、192、256位快高低

5.3. 非對稱加密算法比較

名稱成熟度安全性運算速度資源消耗

RSA 高高中中

ECC 高高慢高

5.4. 對稱算法與非對稱加密算法

5.4.1. 對稱算法

密鑰管理：比較難，不适合網際網路，一般用于内部系統

安全性：中

加密速度：快好幾個數量級 (軟體加解密速度至少快 100 倍，每秒可以加解密數 M 比特資料)，适合大資料量的加解密處理

5.4.2. 非對稱算法

密鑰管理：密鑰容易管理

安全性：高

加密速度：比較慢，适合小資料量加解密或資料簽名

小結

本文介紹了數字簽名，加密和解密，對稱加密和非對稱加密，然後詳細介紹了 MD5，SHA-1，HMAC，DES/AES，RSA 和 ECC 這幾種加密算法和代碼示例。

---------------------

作者：零壹技術棧

來源：CSDN

原文：https://blog.csdn.net/baidu_22254181/article/details/82594072

[java]淺談常用的七種加密算法

繼續閱讀

https和http了解和http1.0、http2.0的對比

Java實作SHA1檔案加密算法

計算機基礎（07）密碼學基礎

12.散清單(上)1.概念2.實作

JavaScript學習 -- AES加密算法

下載下傳安裝Bouncy Castle 密碼包之靜态方法

LeetCode 1248 統計優美子數組

SHA:安全雜湊演算法

國密SM2數字簽名算法

非對稱加密及RSA算法

資料結構與算法分析之散列概念總結

Java DES對稱加密工具類

MD5 到底算不算一種加密算法？

MCGS使用者程式雲端授權系統設計

這些有難度的NodeJS面試題，你能答對幾個？

mbedtls 基礎及其應用