淺談常見的七種加密算法及實現
前言
數字簽名、信息加密 是先後端開發都常常須要使用到的技術，應用場景包括了用戶登入、交易、信息通信、oauth 等等，不一樣的應用場景也會須要使用到不一樣的簽名加密算法，或者須要搭配不同的 簽名加密算法 來達到業務目標。這裏簡單的給你們介紹幾種常見的簽名加密算法和一些典型場景下的應用。java
正文
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;
/** * MAC算法可選如下多種算法 * HmacMD5/HmacSHA1/HmacSHA256/HmacSHA384/HmacSHA512 */
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 | 12八、19二、256位 | 快 | 高 | 低 |
5.3. 非對稱加密算法比較
| 名稱 | 成熟度 | 安全性 | 運算速度 | 資源消耗 |
|---|---|---|---|---|
| RSA | 高 | 高 | 中 | 中 |
| ECC | 高 | 高 | 慢 | 高 |
5.4. 對稱算法與非對稱加密算法
5.4.1. 對稱算法
-
密鑰管理：比較難，不適合互聯網，通常用於內部系統
-
安全性：中
-
加密速度：快好 幾個數量級 (軟件加解密速度至少快
100倍，每秒能夠加解密數M比特 數據)，適合大數據量的加解密處理
5.4.2. 非對稱算法
-
密鑰管理：密鑰容易管理
-
安全性：高
-
加密速度：比較慢，適合 小數據量 加解密或數據簽名
小結
本文介紹了 數字簽名，加密和解密，對稱加密和非對稱加密，而後詳細介紹了 MD5，SHA-1，HMAC，DES/AES，RSA 和 ECC 這幾種加密算法和代碼示例。
歡迎關注技術公衆號： 零壹技術棧
本賬號將持續分享後端技術乾貨，包括虛擬機基礎，多線程編程，高性能框架，異步、緩存和消息中間件，分佈式和微服務，架構學習和進階等學習資料和文章。
相關文章
- 1. 淺談MD5加密算法（JAVA實現）
- 2. 常見加密算法及常見加密算法原理
- 3. 常見加密算法的 JS 實現
- 4. 淺談DES加密算法
- 5. 常見的加密算法
- 6. 五種常見的加密算法及簡單使用
- 7. 常見加密算法
- 8. 常見的加密解密算法
- 9. c# 幾種常見的加密方法的實現
- 10. 常見加密方式及Python實現
- 更多相關文章...
- • Spring實例化Bean的三種方法 - Spring教程
- • 現實生活中的 XML - XML 教程
- • ☆基於Java Instrument的Agent實現
- • Docker容器實戰(七) - 容器眼光下的文件系統
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 淺談MD5加密算法（JAVA實現）
- 2. 常見加密算法及常見加密算法原理
- 3. 常見加密算法的 JS 實現
- 4. 淺談DES加密算法
- 5. 常見的加密算法
- 6. 五種常見的加密算法及簡單使用
- 7. 常見加密算法
- 8. 常見的加密解密算法
- 9. c# 幾種常見的加密方法的實現
- 10. 常見加密方式及Python實現