參考：
- https://mp.weixin.qq.com/s/UBwCpsK7kbPfmI4_PiJJCA
- https://mp.weixin.qq.com/s/hJJUbb6aLbxmNl3k91M7UQ
- http://www.reibang.com/p/1a8837872ed0
今天說一說加解密，我們先了解一下相關(guān)的概念：
- 不可逆加密
- 可逆加密
從加密方式來說不傅，加密分為可逆和不可逆加密微姊，而可逆加密有具體分為：
- 算法加密
- 對(duì)稱加密算法
- 非對(duì)稱加密算法
我們分別說說他們的區(qū)別和特性奕坟。
1.不可逆加密
不可逆加密算法的特征是加密過程中不需要使用密鑰，輸入明文后由系統(tǒng)直接經(jīng)過加密算法處理成密文躲查，這種加密后的數(shù)據(jù)是無法被解密的罩润，只有重新輸入明文，并再次經(jīng)過同樣不可逆的加密算法處理悍及，得到相同的加密密文并被系統(tǒng)重新識(shí)別后，才能真正解密号阿。
如信息摘要（Message Digest）和安全散列（Secure Hash）算法屬于此類并鸵，常見的算法包括 MD5鸳粉、SHA1扔涧、PBKDF2、bcrypt 等届谈。
特點(diǎn)：
image.png
ok,那我們演示如何使用MD5和SHA進(jìn)行加解密
// MD5加密
private static String toMd5(String str) {
// 實(shí)例化一個(gè)指定摘要算法為MD5的MessageDigest對(duì)象
MessageDigest algorithm;
try {
algorithm = MessageDigest.getInstance("MD5");
// 重置摘要以供再次使用
algorithm.reset();
// 使用bytes更新摘要
algorithm.update(str.getBytes());
// 使用指定的byte數(shù)組對(duì)摘要進(jìn)行最后更新,然后完成摘要計(jì)算
return toHexString(algorithm.digest(), "");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
// SHA加密
private static String toSHA(String str) {
// 實(shí)例化一個(gè)指定摘要算法為SHA的MessageDigest對(duì)象
MessageDigest algorithm;
try {
algorithm = MessageDigest.getInstance("SHA");
// 重置摘要以供再次使用
algorithm.reset();
// 使用bytes更新摘要
algorithm.update(str.getBytes());
// 使用指定的byte數(shù)組對(duì)摘要進(jìn)行最后更新,然后完成摘要計(jì)算
return toHexString(algorithm.digest(), "");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
// 將字符串中的每個(gè)字符轉(zhuǎn)換為十六進(jìn)制
private static String toHexString(byte[] bytes, String separtor) {
StringBuilder hexString = new StringBuilder();
for (byte b : bytes) {
String hex = Integer.toHexString(0xff & b);
if (hex.length() == 1) {
hexString.append("0");
}
hexString.append(hex).append(separtor);
}
return hexString.toString();
}
2.可逆加密
2.1算法加密
基于算法的加密算法枯夜，也被稱為古典加密算法，如 HTTP 認(rèn)證中的 base64艰山，是一種基于64個(gè)基本字符湖雹，加密后的內(nèi)容只包含這64個(gè)字符，加密后長度會(huì)變大曙搬。它是最簡(jiǎn)單的一種算法摔吏，一般用于加密URL.
下圖為Base64編碼表
image.png
Base64加解密相關(guān)代碼
需要引入包：android.util.Base64切記是android自帶的
// Base64加密
private static String encode(String str) {
byte[] encodeBytes = Base64.getEncoder().encode(str.getBytes());
return new String(encodeBytes);
}
// Base64解密
private static String decode(String str) {
byte[] decodeBytes = Base64.getDecoder().decode(str.getBytes());
return new String(decodeBytes);
}
2.2對(duì)稱加密
對(duì)稱加密：加密和解密的密鑰一樣。常見的對(duì)稱加密算法有 DES纵装、3DES征讲、AES。這三者的關(guān)系可以理解為迭代和替代橡娄。3DES是對(duì)DES的發(fā)展诗箍，AES是為了替代DES.
DES加解密相關(guān)代碼
public class DESUtil {
// 初始化向量
private static byte[] iv = { 'a', 'b', 'c', 'd', 'e', 1, 2, '*' };
// DES加密
// encryptText為原文
// encryptKey為密匙
private static String encryptDES(String encryptText, String encryptKey)
throws Exception {
// 實(shí)例化IvParameterSpec對(duì)象，使用指定的初始化向量
IvParameterSpec spec = new IvParameterSpec(iv);
// 實(shí)例化SecretKeySpec類,根據(jù)字節(jié)數(shù)組來構(gòu)造SecretKeySpec
SecretKeySpec key = new SecretKeySpec(encryptKey.getBytes(), "DES");
// 創(chuàng)建密碼器
Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
// 用密碼初始化Cipher對(duì)象
cipher.init(Cipher.ENCRYPT_MODE, key, spec);
// 執(zhí)行加密操作
byte[] encryptData = cipher.doFinal(encryptText.getBytes());
// 返回加密后的數(shù)據(jù)
return Base64.getEncoder().encodeToString(encryptData);
}
// 解密
private static String decryptDES(String decryptString, String decryptKey)
throws Exception {
// 先使用Base64解密
byte[] base64byte = Base64.getDecoder().decode(decryptString);
// 實(shí)例化IvParameterSpec對(duì)象挽唉，使用指定的初始化向量
IvParameterSpec spec = new IvParameterSpec(iv);
// 實(shí)例化SecretKeySpec類,根據(jù)字節(jié)數(shù)組來構(gòu)造SecretKeySpec
SecretKeySpec key = new SecretKeySpec(decryptKey.getBytes(), "DES");
// 創(chuàng)建密碼器
Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
// 用密碼初始化Cipher對(duì)象
cipher.init(Cipher.DECRYPT_MODE, key, spec);
// 獲取解密后的數(shù)據(jù)
byte decryptedData[] = cipher.doFinal(base64byte);
// 將解密后數(shù)據(jù)轉(zhuǎn)換為字符串輸出
return new String(decryptedData);
}
}
AES加解密相關(guān)代碼
public class AESUtil {
// 采用對(duì)稱分組密碼體制,密鑰長度的最少支持為128滤祖、192筷狼、256
String key = "abcdefghijklmnop";
// 初始化向量參數(shù)，AES 為16bytes. DES 為8bytes匠童， 16*8=128
String initVector = "0000000000000000";
IvParameterSpec iv;
SecretKeySpec skeySpec;
Cipher cipher;
private static class HOLDER {
private static AESUtil instance = new AESUtil();
}
public static AESUtil getInstance() {
return HOLDER.instance;
}
private AESUtil() {
try {
iv = new IvParameterSpec(initVector.getBytes("UTF-8"));
skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
// 這是CBC模式
// cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
// 默認(rèn)就是ECB模式
cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
public String encrypt(String value) {
try {
// CBC模式需要傳入向量埂材，ECB模式不需要
// cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
byte[] encrypted = cipher.doFinal(value.getBytes());
return Base64.encodeToString(encrypted, Base64.DEFAULT);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public String decrypt(String encrypted) {
try {
// CBC模式需要傳入向量，ECB模式不需要
// cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] original = cipher.doFinal(Base64.decode(encrypted, Base64.DEFAULT));
return new String(original);
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
2.3非對(duì)稱加密
非對(duì)稱加密：加密和解密的密鑰不同俏让，通常是公鑰加密私鑰解密楞遏，當(dāng)然也可以私鑰加密公鑰解密，公鑰通常用來對(duì)內(nèi)容加密首昔，而私鑰既可以解密也可以用來確定是否是對(duì)應(yīng)的公鑰加的密寡喝，防止他人用錯(cuò)誤的公鑰進(jìn)行加密。
非對(duì)稱加密中另外兩個(gè)重要的概念是公鑰和私鑰勒奇。公鑰對(duì)外公開预鬓，任何人均可持有和使用；私鑰自行保管赊颠，其安全性是通信安危的關(guān)鍵格二。常見的算法有 RSA、DH（Diffie-Hellman）竣蹦、橢圓曲線算法（Elliptic curve cryptography顶猜，ECC）。
私鑰和公鑰的作用一般分為兩種：
公鑰加密痘括，私鑰解密长窄，主要用于通信；
私鑰加密（簽名）纲菌，公鑰解密（驗(yàn)證）挠日，主要用于數(shù)字簽名。
RSA算法相關(guān)代碼
public class RSAUtil {
public static final String RSA = "RSA";
public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";
// 秘鑰默認(rèn)長度
public static final int DEFAULT_KEY_SIZE = 2048;
// 當(dāng)要加密的內(nèi)容超過bufferSize翰舌，則采用partSplit進(jìn)行分塊加密
public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes();
// 當(dāng)前秘鑰支持加密的最大字節(jié)數(shù)
public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;
// 隨機(jī)生成RSA密鑰對(duì)嚣潜，密鑰長度，范圍：512～2048
public static KeyPair generateRSAKeyPair(int keyLength) {
try {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
return kpg.genKeyPair();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
/**
* 私鑰加密
* @param data 待加密數(shù)據(jù)
* @param privateKey 密鑰
* @return byte[] 加密數(shù)據(jù)
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
// 得到私鑰
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
// 數(shù)據(jù)加密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);
return cipher.doFinal(data);
}
// 使用私鑰進(jìn)行解密
public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception {
// 得到私鑰
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
// 解密數(shù)據(jù)
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.DECRYPT_MODE, keyPrivate);
byte[] arr = cp.doFinal(encrypted);
return arr;
}
// 用公鑰對(duì)字符串進(jìn)行加密
public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 得到公鑰
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 加密數(shù)據(jù)
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.ENCRYPT_MODE, keyPublic);
return cp.doFinal(data);
}
/**
* 公鑰解密
* @param data 待解密數(shù)據(jù)
* @param publicKey 密鑰
* @return byte[] 解密數(shù)據(jù)
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
// 得到公鑰
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
// 數(shù)據(jù)解密
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.DECRYPT_MODE, keyPublic);
return cipher.doFinal(data);
}
// 以下開始分段解密
// 使用私鑰分段解密
public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
if (splitLen <= 0) {
return decryptByPrivateKey(encrypted, privateKey);
}
int dataLen = encrypted.length;
List<Byte> allBytes = new ArrayList<Byte>(1024);
int latestStartIndex = 0;
for (int i = 0; i < dataLen; i++) {
byte bt = encrypted[i];
boolean isMatchSplit = false;
if (i == dataLen - 1) {
// 到data的最后了
byte[] part = new byte[dataLen - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPrivateKey(part, privateKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
} else if (bt == DEFAULT_SPLIT[0]) {
// 這個(gè)是以split[0]開頭
if (splitLen > 1) {
if (i + splitLen < dataLen) {
// 沒有超出data的范圍
for (int j = 1; j < splitLen; j++) {
if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
break;
}
if (j == splitLen - 1) {
// 驗(yàn)證到split的最后一位椅贱，都沒有break懂算，則表明已經(jīng)確認(rèn)是split段
isMatchSplit = true;
}
}
}
} else {
// split只有一位，則已經(jīng)匹配了
isMatchSplit = true;
}
}
if (isMatchSplit) {
byte[] part = new byte[i - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPrivateKey(part, privateKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
// 私鑰分段加密
public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {
int dataLen = data.length;
if (dataLen <= DEFAULT_BUFFERSIZE) {
return encryptByPrivateKey(data, privateKey);
}
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFERSIZE];
for (int i = 0; i < dataLen; i++) {
buf[bufIndex] = data[i];
if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
subDataLoop++;
if (subDataLoop != 1) {
for (byte b : DEFAULT_SPLIT) {
allBytes.add(b);
}
}
byte[] encryptBytes = encryptByPrivateKey(buf, privateKey);
for (byte b : encryptBytes) {
allBytes.add(b);
}
bufIndex = 0;
if (i == dataLen - 1) {
buf = null;
} else {
buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
// 用公鑰對(duì)字符串進(jìn)行分段加密
public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {
int dataLen = data.length;
if (dataLen <= DEFAULT_BUFFERSIZE) {
return encryptByPublicKey(data, publicKey);
}
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFERSIZE];
for (int i = 0; i < dataLen; i++) {
buf[bufIndex] = data[i];
if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
subDataLoop++;
if (subDataLoop != 1) {
for (byte b : DEFAULT_SPLIT) {
allBytes.add(b);
}
}
byte[] encryptBytes = encryptByPublicKey(buf, publicKey);
for (byte b : encryptBytes) {
allBytes.add(b);
}
bufIndex = 0;
if (i == dataLen - 1) {
buf = null;
} else {
buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
// 公鑰分段解密
public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
if (splitLen <= 0) {
return decryptByPublicKey(encrypted, publicKey);
}
int dataLen = encrypted.length;
List<Byte> allBytes = new ArrayList<Byte>(1024);
int latestStartIndex = 0;
for (int i = 0; i < dataLen; i++) {
byte bt = encrypted[i];
boolean isMatchSplit = false;
if (i == dataLen - 1) {
// 到data的最后了
byte[] part = new byte[dataLen - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPublicKey(part, publicKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
} else if (bt == DEFAULT_SPLIT[0]) {
// 這個(gè)是以split[0]開頭
if (splitLen > 1) {
if (i + splitLen < dataLen) {
// 沒有超出data的范圍
for (int j = 1; j < splitLen; j++) {
if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
break;
}
if (j == splitLen - 1) {
// 驗(yàn)證到split的最后一位庇麦，都沒有break计技，則表明已經(jīng)確認(rèn)是split段
isMatchSplit = true;
}
}
}
} else {
// split只有一位，則已經(jīng)匹配了
isMatchSplit = true;
}
}
if (isMatchSplit) {
byte[] part = new byte[i - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPublicKey(part, publicKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
}
3.數(shù)字簽名
數(shù)字簽名的出現(xiàn)一個(gè)很重要的作用是解決私鑰加密文件過大女器，耗時(shí)過長酸役。同樣公鑰解密的過程中也很耗時(shí)。
數(shù)字簽名我們來舉一個(gè)例子：
第一步：.故事主人公A要給B發(fā)送一個(gè)文件，他首先用哈希算法對(duì)文件進(jìn)行加密得到哈希值涣澡，稱之為摘要,取名HashA贱呐。
第二步：對(duì)生成的哈希值進(jìn)行私鑰加密，稱之為數(shù)字簽名入桂。
第三步：A將數(shù)字簽名和文件一起發(fā)送給B奄薇。
第四步：B對(duì)數(shù)字簽名進(jìn)行公鑰解密得到Hash值即摘要，如果成功表示來自A抗愁。
第五步：B和A一樣對(duì)正文進(jìn)行摘要得到Hash值馁蒂，取名HashB,對(duì)比同A的HaahA.如果一致表示文件沒有被篡改。
總結(jié)：數(shù)字簽名可以保證文件的來源(即文件來自于B)和完整性.
4.數(shù)字證書
說到數(shù)字證書蜘腌，我們還需要拿上面的例子沫屡，說明一下數(shù)字簽名的局限性。我們都知道公鑰通常是公開的保存在本地的撮珠，如果此時(shí)有個(gè)C沮脖，在B的本地將A的公鑰替換為自己的公鑰，同時(shí)用自己的私鑰加密數(shù)據(jù)傳遞給B芯急，這樣B是沒有辦法辨別的勺届。
為了解決這個(gè)問題，我們引入了CA認(rèn)證娶耍，也就是A拿著自己的公鑰去CA中心做認(rèn)證,證書中心用自己的私鑰免姿，對(duì)A的公鑰和一些相關(guān)信息一起加密，生成"數(shù)字證書"（Digital Certificate）榕酒。然后將之前的數(shù)字簽名胚膊，正文內(nèi)容，數(shù)字證書一起發(fā)送給B奈应。
B這邊怎么做呢澜掩？B用CA給的公鑰先解密數(shù)字證書得到A的公鑰(注意之前公鑰可能保存在B的本地中购披，現(xiàn)在改為網(wǎng)絡(luò)傳輸了)杖挣，然后用A的公鑰解密數(shù)字簽名，在解密的正文和傳遞的正文作比較刚陡。
說了這么多惩妇，CA是什么呢？
CA證書就是電子商務(wù)認(rèn)證授權(quán)機(jī)構(gòu)筐乳，也稱為電子商務(wù)認(rèn)證中心歌殃，是負(fù)責(zé)發(fā)放和管理數(shù)字證書的權(quán)威機(jī)構(gòu)，并作為電子商務(wù)交易中受信任的第三方蝙云，承擔(dān)公鑰體系中公鑰的合法性檢驗(yàn)的責(zé)任氓皱。
證書的內(nèi)容包括：電子簽證機(jī)關(guān)的信息、公鑰用戶信息、公鑰波材、權(quán)威機(jī)構(gòu)的簽字和有效期等等股淡。目前，證書的格式和驗(yàn)證方法普遍遵循X.509 國際標(biāo)準(zhǔn)廷区。
所以說CA具有可靠性唯灵，也就是說CA生成的數(shù)字證書也具有可靠性，如果數(shù)字證書被中途篡改隙轻，是無法被CA的公鑰解密的要是有多個(gè)人要給B發(fā)郵件埠帕，難道B要保存1萬份不同的CA公鑰嗎？
答案：不需要玖绿，CA認(rèn)證中心給可以給B一份“根證書”敛瓷，里面存儲(chǔ)CA公鑰來驗(yàn)證所有CA分中心頒發(fā)的數(shù)字證書。CA中心是分叉樹結(jié)構(gòu)斑匪，類似于公安部->省公安廳->市級(jí)派出所琐驴，不管A從哪個(gè)CA分支機(jī)構(gòu)申請(qǐng)的證書白热，B只要預(yù)存根證書就可以驗(yàn)證下級(jí)證書可靠性梁只。
關(guān)于加解密，主要內(nèi)容就這么多锄贷。
